001/* 002 * CDDL HEADER START 003 * 004 * The contents of this file are subject to the terms of the 005 * Common Development and Distribution License, Version 1.0 only 006 * (the "License"). You may not use this file except in compliance 007 * with the License. 008 * 009 * You can obtain a copy of the license at legal-notices/CDDLv1_0.txt 010 * or http://forgerock.org/license/CDDLv1.0.html. 011 * See the License for the specific language governing permissions 012 * and limitations under the License. 013 * 014 * When distributing Covered Code, include this CDDL HEADER in each 015 * file and include the License file at legal-notices/CDDLv1_0.txt. 016 * If applicable, add the following below this CDDL HEADER, with the 017 * fields enclosed by brackets "[]" replaced with your own identifying 018 * information: 019 * Portions Copyright [yyyy] [name of copyright owner] 020 * 021 * CDDL HEADER END 022 * 023 * 024 * Copyright 2008 Sun Microsystems, Inc. 025 */ 026package org.forgerock.opendj.server.config.client; 027 028 029 030import java.util.Collection; 031import java.util.SortedSet; 032import org.forgerock.opendj.config.client.ConcurrentModificationException; 033import org.forgerock.opendj.config.client.IllegalManagedObjectNameException; 034import org.forgerock.opendj.config.client.ManagedObjectDecodingException; 035import org.forgerock.opendj.config.client.OperationRejectedException; 036import org.forgerock.opendj.config.DefinitionDecodingException; 037import org.forgerock.opendj.config.ManagedObjectDefinition; 038import org.forgerock.opendj.config.ManagedObjectNotFoundException; 039import org.forgerock.opendj.config.PropertyException; 040import org.forgerock.opendj.ldap.LdapException; 041import org.forgerock.opendj.server.config.meta.BackendCfgDefn.WritabilityMode; 042import org.forgerock.opendj.server.config.server.LocalDBBackendCfg; 043import org.forgerock.opendj.server.config.server.LocalDBIndexCfg; 044import org.forgerock.opendj.server.config.server.LocalDBVLVIndexCfg; 045 046 047 048/** 049 * A client-side interface for reading and modifying Local DB Backend 050 * settings. 051 * <p> 052 * The Local DB Backend uses the Berkeley DB Java Edition to store 053 * user-provided data in a local repository. 054 */ 055public interface LocalDBBackendCfgClient extends BackendCfgClient { 056 057 /** 058 * Get the configuration definition associated with this Local DB Backend. 059 * 060 * @return Returns the configuration definition associated with this Local DB Backend. 061 */ 062 ManagedObjectDefinition<? extends LocalDBBackendCfgClient, ? extends LocalDBBackendCfg> definition(); 063 064 065 066 /** 067 * Gets the "compact-encoding" property. 068 * <p> 069 * Indicates whether the backend should use a compact form when 070 * encoding entries by compressing the attribute descriptions and 071 * object class sets. 072 * <p> 073 * Note that this property applies only to the entries themselves 074 * and does not impact the index data. 075 * 076 * @return Returns the value of the "compact-encoding" property. 077 */ 078 boolean isCompactEncoding(); 079 080 081 082 /** 083 * Sets the "compact-encoding" property. 084 * <p> 085 * Indicates whether the backend should use a compact form when 086 * encoding entries by compressing the attribute descriptions and 087 * object class sets. 088 * <p> 089 * Note that this property applies only to the entries themselves 090 * and does not impact the index data. 091 * 092 * @param value The value of the "compact-encoding" property. 093 * @throws PropertyException 094 * If the new value is invalid. 095 */ 096 void setCompactEncoding(Boolean value) throws PropertyException; 097 098 099 100 /** 101 * Gets the "db-cache-percent" property. 102 * <p> 103 * Specifies the percentage of JVM memory to allocate to the 104 * database cache. 105 * <p> 106 * Specifies the percentage of memory available to the JVM that 107 * should be used for caching database contents. Note that this is 108 * only used if the value of the db-cache-size property is set to "0 109 * MB". Otherwise, the value of that property is used instead to 110 * control the cache size configuration. 111 * 112 * @return Returns the value of the "db-cache-percent" property. 113 */ 114 int getDBCachePercent(); 115 116 117 118 /** 119 * Sets the "db-cache-percent" property. 120 * <p> 121 * Specifies the percentage of JVM memory to allocate to the 122 * database cache. 123 * <p> 124 * Specifies the percentage of memory available to the JVM that 125 * should be used for caching database contents. Note that this is 126 * only used if the value of the db-cache-size property is set to "0 127 * MB". Otherwise, the value of that property is used instead to 128 * control the cache size configuration. 129 * 130 * @param value The value of the "db-cache-percent" property. 131 * @throws PropertyException 132 * If the new value is invalid. 133 */ 134 void setDBCachePercent(Integer value) throws PropertyException; 135 136 137 138 /** 139 * Gets the "db-cache-size" property. 140 * <p> 141 * The amount of JVM memory to allocate to the database cache. 142 * <p> 143 * Specifies the amount of memory that should be used for caching 144 * database contents. A value of "0 MB" indicates that the 145 * db-cache-percent property should be used instead to specify the 146 * cache size. 147 * 148 * @return Returns the value of the "db-cache-size" property. 149 */ 150 long getDBCacheSize(); 151 152 153 154 /** 155 * Sets the "db-cache-size" property. 156 * <p> 157 * The amount of JVM memory to allocate to the database cache. 158 * <p> 159 * Specifies the amount of memory that should be used for caching 160 * database contents. A value of "0 MB" indicates that the 161 * db-cache-percent property should be used instead to specify the 162 * cache size. 163 * 164 * @param value The value of the "db-cache-size" property. 165 * @throws PropertyException 166 * If the new value is invalid. 167 */ 168 void setDBCacheSize(Long value) throws PropertyException; 169 170 171 172 /** 173 * Gets the "db-checkpointer-bytes-interval" property. 174 * <p> 175 * Specifies the maximum number of bytes that may be written to the 176 * database before it is forced to perform a checkpoint. 177 * <p> 178 * This can be used to bound the recovery time that may be required 179 * if the database environment is opened without having been properly 180 * closed. If this property is set to a non-zero value, the 181 * checkpointer wakeup interval is not used. To use time-based 182 * checkpointing, set this property to zero. 183 * 184 * @return Returns the value of the "db-checkpointer-bytes-interval" property. 185 */ 186 long getDBCheckpointerBytesInterval(); 187 188 189 190 /** 191 * Sets the "db-checkpointer-bytes-interval" property. 192 * <p> 193 * Specifies the maximum number of bytes that may be written to the 194 * database before it is forced to perform a checkpoint. 195 * <p> 196 * This can be used to bound the recovery time that may be required 197 * if the database environment is opened without having been properly 198 * closed. If this property is set to a non-zero value, the 199 * checkpointer wakeup interval is not used. To use time-based 200 * checkpointing, set this property to zero. 201 * 202 * @param value The value of the "db-checkpointer-bytes-interval" property. 203 * @throws PropertyException 204 * If the new value is invalid. 205 */ 206 void setDBCheckpointerBytesInterval(Long value) throws PropertyException; 207 208 209 210 /** 211 * Gets the "db-checkpointer-wakeup-interval" property. 212 * <p> 213 * Specifies the maximum length of time that may pass between 214 * checkpoints. 215 * <p> 216 * Note that this is only used if the value of the checkpointer 217 * bytes interval is zero. 218 * 219 * @return Returns the value of the "db-checkpointer-wakeup-interval" property. 220 */ 221 long getDBCheckpointerWakeupInterval(); 222 223 224 225 /** 226 * Sets the "db-checkpointer-wakeup-interval" property. 227 * <p> 228 * Specifies the maximum length of time that may pass between 229 * checkpoints. 230 * <p> 231 * Note that this is only used if the value of the checkpointer 232 * bytes interval is zero. 233 * 234 * @param value The value of the "db-checkpointer-wakeup-interval" property. 235 * @throws PropertyException 236 * If the new value is invalid. 237 */ 238 void setDBCheckpointerWakeupInterval(Long value) throws PropertyException; 239 240 241 242 /** 243 * Gets the "db-cleaner-min-utilization" property. 244 * <p> 245 * Specifies the minimum percentage of "live" data that the database 246 * cleaner attempts to keep in database log files. 247 * <p> 248 * If the amount of live data in any database log file drops below 249 * this percentage, then the cleaner moves the remaining live data in 250 * that file to the end of the database and deletes the original file 251 * in order to keep the database relatively compact. 252 * 253 * @return Returns the value of the "db-cleaner-min-utilization" property. 254 */ 255 int getDBCleanerMinUtilization(); 256 257 258 259 /** 260 * Sets the "db-cleaner-min-utilization" property. 261 * <p> 262 * Specifies the minimum percentage of "live" data that the database 263 * cleaner attempts to keep in database log files. 264 * <p> 265 * If the amount of live data in any database log file drops below 266 * this percentage, then the cleaner moves the remaining live data in 267 * that file to the end of the database and deletes the original file 268 * in order to keep the database relatively compact. 269 * 270 * @param value The value of the "db-cleaner-min-utilization" property. 271 * @throws PropertyException 272 * If the new value is invalid. 273 */ 274 void setDBCleanerMinUtilization(Integer value) throws PropertyException; 275 276 277 278 /** 279 * Gets the "db-directory" property. 280 * <p> 281 * Specifies the path to the filesystem directory that is used to 282 * hold the Berkeley DB Java Edition database files containing the 283 * data for this backend. 284 * <p> 285 * The path may be either an absolute path or a path relative to the 286 * directory containing the base of the OpenDJ directory server 287 * installation. The path may be any valid directory path in which 288 * the server has appropriate permissions to read and write files and 289 * has sufficient space to hold the database contents. 290 * 291 * @return Returns the value of the "db-directory" property. 292 */ 293 String getDBDirectory(); 294 295 296 297 /** 298 * Sets the "db-directory" property. 299 * <p> 300 * Specifies the path to the filesystem directory that is used to 301 * hold the Berkeley DB Java Edition database files containing the 302 * data for this backend. 303 * <p> 304 * The path may be either an absolute path or a path relative to the 305 * directory containing the base of the OpenDJ directory server 306 * installation. The path may be any valid directory path in which 307 * the server has appropriate permissions to read and write files and 308 * has sufficient space to hold the database contents. 309 * 310 * @param value The value of the "db-directory" property. 311 * @throws PropertyException 312 * If the new value is invalid. 313 */ 314 void setDBDirectory(String value) throws PropertyException; 315 316 317 318 /** 319 * Gets the "db-directory-permissions" property. 320 * <p> 321 * Specifies the permissions that should be applied to the directory 322 * containing the server database files. 323 * <p> 324 * They should be expressed as three-digit octal values, which is 325 * the traditional representation for UNIX file permissions. The 326 * three digits represent the permissions that are available for the 327 * directory's owner, group members, and other users (in that order), 328 * and each digit is the octal representation of the read, write, and 329 * execute bits. Note that this only impacts permissions on the 330 * database directory and not on the files written into that 331 * directory. On UNIX systems, the user's umask controls permissions 332 * given to the database files. 333 * 334 * @return Returns the value of the "db-directory-permissions" property. 335 */ 336 String getDBDirectoryPermissions(); 337 338 339 340 /** 341 * Sets the "db-directory-permissions" property. 342 * <p> 343 * Specifies the permissions that should be applied to the directory 344 * containing the server database files. 345 * <p> 346 * They should be expressed as three-digit octal values, which is 347 * the traditional representation for UNIX file permissions. The 348 * three digits represent the permissions that are available for the 349 * directory's owner, group members, and other users (in that order), 350 * and each digit is the octal representation of the read, write, and 351 * execute bits. Note that this only impacts permissions on the 352 * database directory and not on the files written into that 353 * directory. On UNIX systems, the user's umask controls permissions 354 * given to the database files. 355 * 356 * @param value The value of the "db-directory-permissions" property. 357 * @throws PropertyException 358 * If the new value is invalid. 359 */ 360 void setDBDirectoryPermissions(String value) throws PropertyException; 361 362 363 364 /** 365 * Gets the "db-evictor-core-threads" property. 366 * <p> 367 * Specifies the core number of threads in the eviction thread pool. 368 * <p> 369 * Specifies the core number of threads in the eviction thread pool. 370 * These threads help keep memory usage within cache bounds, 371 * offloading work from application threads. db-evictor-core-threads, 372 * db-evictor-max-threads and db-evictor-keep-alive are used to 373 * configure the core, max and keepalive attributes for the eviction 374 * thread pool. 375 * 376 * @return Returns the value of the "db-evictor-core-threads" property. 377 */ 378 int getDBEvictorCoreThreads(); 379 380 381 382 /** 383 * Sets the "db-evictor-core-threads" property. 384 * <p> 385 * Specifies the core number of threads in the eviction thread pool. 386 * <p> 387 * Specifies the core number of threads in the eviction thread pool. 388 * These threads help keep memory usage within cache bounds, 389 * offloading work from application threads. db-evictor-core-threads, 390 * db-evictor-max-threads and db-evictor-keep-alive are used to 391 * configure the core, max and keepalive attributes for the eviction 392 * thread pool. 393 * 394 * @param value The value of the "db-evictor-core-threads" property. 395 * @throws PropertyException 396 * If the new value is invalid. 397 */ 398 void setDBEvictorCoreThreads(Integer value) throws PropertyException; 399 400 401 402 /** 403 * Gets the "db-evictor-keep-alive" property. 404 * <p> 405 * The duration that excess threads in the eviction thread pool will 406 * stay idle. After this period, idle threads will terminate. 407 * <p> 408 * The duration that excess threads in the eviction thread pool will 409 * stay idle. After this period, idle threads will terminate. 410 * db-evictor-core-threads, db-evictor-max-threads and 411 * db-evictor-keep-alive are used to configure the core, max and 412 * keepalive attributes for the eviction thread pool. 413 * 414 * @return Returns the value of the "db-evictor-keep-alive" property. 415 */ 416 long getDBEvictorKeepAlive(); 417 418 419 420 /** 421 * Sets the "db-evictor-keep-alive" property. 422 * <p> 423 * The duration that excess threads in the eviction thread pool will 424 * stay idle. After this period, idle threads will terminate. 425 * <p> 426 * The duration that excess threads in the eviction thread pool will 427 * stay idle. After this period, idle threads will terminate. 428 * db-evictor-core-threads, db-evictor-max-threads and 429 * db-evictor-keep-alive are used to configure the core, max and 430 * keepalive attributes for the eviction thread pool. 431 * 432 * @param value The value of the "db-evictor-keep-alive" property. 433 * @throws PropertyException 434 * If the new value is invalid. 435 */ 436 void setDBEvictorKeepAlive(Long value) throws PropertyException; 437 438 439 440 /** 441 * Gets the "db-evictor-lru-only" property. 442 * <p> 443 * Indicates whether the database should evict existing data from 444 * the cache based on an LRU policy (where the least recently used 445 * information will be evicted first). 446 * <p> 447 * If set to "false", then the eviction keeps internal nodes of the 448 * underlying Btree in the cache over leaf nodes, even if the leaf 449 * nodes have been accessed more recently. This may be a better 450 * configuration for databases in which only a very small portion of 451 * the data is cached. 452 * 453 * @return Returns the value of the "db-evictor-lru-only" property. 454 */ 455 boolean isDBEvictorLruOnly(); 456 457 458 459 /** 460 * Sets the "db-evictor-lru-only" property. 461 * <p> 462 * Indicates whether the database should evict existing data from 463 * the cache based on an LRU policy (where the least recently used 464 * information will be evicted first). 465 * <p> 466 * If set to "false", then the eviction keeps internal nodes of the 467 * underlying Btree in the cache over leaf nodes, even if the leaf 468 * nodes have been accessed more recently. This may be a better 469 * configuration for databases in which only a very small portion of 470 * the data is cached. 471 * 472 * @param value The value of the "db-evictor-lru-only" property. 473 * @throws PropertyException 474 * If the new value is invalid. 475 */ 476 void setDBEvictorLruOnly(Boolean value) throws PropertyException; 477 478 479 480 /** 481 * Gets the "db-evictor-max-threads" property. 482 * <p> 483 * Specifies the maximum number of threads in the eviction thread 484 * pool. 485 * <p> 486 * Specifies the maximum number of threads in the eviction thread 487 * pool. These threads help keep memory usage within cache bounds, 488 * offloading work from application threads. db-evictor-core-threads, 489 * db-evictor-max-threads and db-evictor-keep-alive are used to 490 * configure the core, max and keepalive attributes for the eviction 491 * thread pool. 492 * 493 * @return Returns the value of the "db-evictor-max-threads" property. 494 */ 495 int getDBEvictorMaxThreads(); 496 497 498 499 /** 500 * Sets the "db-evictor-max-threads" property. 501 * <p> 502 * Specifies the maximum number of threads in the eviction thread 503 * pool. 504 * <p> 505 * Specifies the maximum number of threads in the eviction thread 506 * pool. These threads help keep memory usage within cache bounds, 507 * offloading work from application threads. db-evictor-core-threads, 508 * db-evictor-max-threads and db-evictor-keep-alive are used to 509 * configure the core, max and keepalive attributes for the eviction 510 * thread pool. 511 * 512 * @param value The value of the "db-evictor-max-threads" property. 513 * @throws PropertyException 514 * If the new value is invalid. 515 */ 516 void setDBEvictorMaxThreads(Integer value) throws PropertyException; 517 518 519 520 /** 521 * Gets the "db-evictor-nodes-per-scan" property. 522 * <p> 523 * Specifies the number of Btree nodes that should be evicted from 524 * the cache in a single pass if it is determined that it is 525 * necessary to free existing data in order to make room for new 526 * information. 527 * <p> 528 * Changes to this property do not take effect until the backend is 529 * restarted. It is recommended that you also change this property 530 * when you set db-evictor-lru-only to false. This setting controls 531 * the number of Btree nodes that are considered, or sampled, each 532 * time a node is evicted. A setting of 10 often produces good 533 * results, but this may vary from application to application. The 534 * larger the nodes per scan, the more accurate the algorithm. 535 * However, don't set it too high. When considering larger numbers of 536 * nodes for each eviction, the evictor may delay the completion of a 537 * given database operation, which impacts the response time of the 538 * application thread. In JE 4.1 and later, setting this value too 539 * high in an application that is largely CPU bound can reduce the 540 * effectiveness of cache eviction. It's best to start with the 541 * default value, and increase it gradually to see if it is 542 * beneficial for your application. 543 * 544 * @return Returns the value of the "db-evictor-nodes-per-scan" property. 545 */ 546 int getDBEvictorNodesPerScan(); 547 548 549 550 /** 551 * Sets the "db-evictor-nodes-per-scan" property. 552 * <p> 553 * Specifies the number of Btree nodes that should be evicted from 554 * the cache in a single pass if it is determined that it is 555 * necessary to free existing data in order to make room for new 556 * information. 557 * <p> 558 * Changes to this property do not take effect until the backend is 559 * restarted. It is recommended that you also change this property 560 * when you set db-evictor-lru-only to false. This setting controls 561 * the number of Btree nodes that are considered, or sampled, each 562 * time a node is evicted. A setting of 10 often produces good 563 * results, but this may vary from application to application. The 564 * larger the nodes per scan, the more accurate the algorithm. 565 * However, don't set it too high. When considering larger numbers of 566 * nodes for each eviction, the evictor may delay the completion of a 567 * given database operation, which impacts the response time of the 568 * application thread. In JE 4.1 and later, setting this value too 569 * high in an application that is largely CPU bound can reduce the 570 * effectiveness of cache eviction. It's best to start with the 571 * default value, and increase it gradually to see if it is 572 * beneficial for your application. 573 * 574 * @param value The value of the "db-evictor-nodes-per-scan" property. 575 * @throws PropertyException 576 * If the new value is invalid. 577 */ 578 void setDBEvictorNodesPerScan(Integer value) throws PropertyException; 579 580 581 582 /** 583 * Gets the "db-log-filecache-size" property. 584 * <p> 585 * Specifies the size of the file handle cache. 586 * <p> 587 * The file handle cache is used to keep as much opened log files as 588 * possible. When the cache is smaller than the number of logs, the 589 * database needs to close some handles and open log files it needs, 590 * resulting in less optimal performances. Ideally, the size of the 591 * cache should be higher than the number of files contained in the 592 * database. Make sure the OS number of open files per process is 593 * also tuned appropriately. 594 * 595 * @return Returns the value of the "db-log-filecache-size" property. 596 */ 597 int getDBLogFilecacheSize(); 598 599 600 601 /** 602 * Sets the "db-log-filecache-size" property. 603 * <p> 604 * Specifies the size of the file handle cache. 605 * <p> 606 * The file handle cache is used to keep as much opened log files as 607 * possible. When the cache is smaller than the number of logs, the 608 * database needs to close some handles and open log files it needs, 609 * resulting in less optimal performances. Ideally, the size of the 610 * cache should be higher than the number of files contained in the 611 * database. Make sure the OS number of open files per process is 612 * also tuned appropriately. 613 * 614 * @param value The value of the "db-log-filecache-size" property. 615 * @throws PropertyException 616 * If the new value is invalid. 617 */ 618 void setDBLogFilecacheSize(Integer value) throws PropertyException; 619 620 621 622 /** 623 * Gets the "db-log-file-max" property. 624 * <p> 625 * Specifies the maximum size for a database log file. 626 * 627 * @return Returns the value of the "db-log-file-max" property. 628 */ 629 long getDBLogFileMax(); 630 631 632 633 /** 634 * Sets the "db-log-file-max" property. 635 * <p> 636 * Specifies the maximum size for a database log file. 637 * 638 * @param value The value of the "db-log-file-max" property. 639 * @throws PropertyException 640 * If the new value is invalid. 641 */ 642 void setDBLogFileMax(Long value) throws PropertyException; 643 644 645 646 /** 647 * Gets the "db-logging-file-handler-on" property. 648 * <p> 649 * Indicates whether the database should maintain a je.info file in 650 * the same directory as the database log directory. 651 * <p> 652 * This file contains information about the internal processing 653 * performed by the underlying database. 654 * 655 * @return Returns the value of the "db-logging-file-handler-on" property. 656 */ 657 boolean isDBLoggingFileHandlerOn(); 658 659 660 661 /** 662 * Sets the "db-logging-file-handler-on" property. 663 * <p> 664 * Indicates whether the database should maintain a je.info file in 665 * the same directory as the database log directory. 666 * <p> 667 * This file contains information about the internal processing 668 * performed by the underlying database. 669 * 670 * @param value The value of the "db-logging-file-handler-on" property. 671 * @throws PropertyException 672 * If the new value is invalid. 673 */ 674 void setDBLoggingFileHandlerOn(Boolean value) throws PropertyException; 675 676 677 678 /** 679 * Gets the "db-logging-level" property. 680 * <p> 681 * Specifies the log level that should be used by the database when 682 * it is writing information into the je.info file. 683 * <p> 684 * The database trace logging level is (in increasing order of 685 * verbosity) chosen from: OFF, SEVERE, WARNING, INFO, CONFIG, FINE, 686 * FINER, FINEST, ALL. 687 * 688 * @return Returns the value of the "db-logging-level" property. 689 */ 690 String getDBLoggingLevel(); 691 692 693 694 /** 695 * Sets the "db-logging-level" property. 696 * <p> 697 * Specifies the log level that should be used by the database when 698 * it is writing information into the je.info file. 699 * <p> 700 * The database trace logging level is (in increasing order of 701 * verbosity) chosen from: OFF, SEVERE, WARNING, INFO, CONFIG, FINE, 702 * FINER, FINEST, ALL. 703 * 704 * @param value The value of the "db-logging-level" property. 705 * @throws PropertyException 706 * If the new value is invalid. 707 */ 708 void setDBLoggingLevel(String value) throws PropertyException; 709 710 711 712 /** 713 * Gets the "db-num-cleaner-threads" property. 714 * <p> 715 * Specifies the number of threads that the backend should maintain 716 * to keep the database log files at or near the desired utilization. 717 * <p> 718 * In environments with high write throughput, multiple cleaner 719 * threads may be required to maintain the desired utilization. 720 * 721 * @return Returns the value of the "db-num-cleaner-threads" property. 722 */ 723 Integer getDBNumCleanerThreads(); 724 725 726 727 /** 728 * Sets the "db-num-cleaner-threads" property. 729 * <p> 730 * Specifies the number of threads that the backend should maintain 731 * to keep the database log files at or near the desired utilization. 732 * <p> 733 * In environments with high write throughput, multiple cleaner 734 * threads may be required to maintain the desired utilization. 735 * 736 * @param value The value of the "db-num-cleaner-threads" property. 737 * @throws PropertyException 738 * If the new value is invalid. 739 */ 740 void setDBNumCleanerThreads(Integer value) throws PropertyException; 741 742 743 744 /** 745 * Gets the "db-num-lock-tables" property. 746 * <p> 747 * Specifies the number of lock tables that are used by the 748 * underlying database. 749 * <p> 750 * This can be particularly important to help improve scalability by 751 * avoiding contention on systems with large numbers of CPUs. The 752 * value of this configuration property should be set to a prime 753 * number that is less than or equal to the number of worker threads 754 * configured for use in the server. 755 * 756 * @return Returns the value of the "db-num-lock-tables" property. 757 */ 758 Integer getDBNumLockTables(); 759 760 761 762 /** 763 * Sets the "db-num-lock-tables" property. 764 * <p> 765 * Specifies the number of lock tables that are used by the 766 * underlying database. 767 * <p> 768 * This can be particularly important to help improve scalability by 769 * avoiding contention on systems with large numbers of CPUs. The 770 * value of this configuration property should be set to a prime 771 * number that is less than or equal to the number of worker threads 772 * configured for use in the server. 773 * 774 * @param value The value of the "db-num-lock-tables" property. 775 * @throws PropertyException 776 * If the new value is invalid. 777 */ 778 void setDBNumLockTables(Integer value) throws PropertyException; 779 780 781 782 /** 783 * Gets the "db-run-cleaner" property. 784 * <p> 785 * Indicates whether the database cleaner threads should be enabled. 786 * <p> 787 * The cleaner threads are used to periodically compact the database 788 * by identifying database files with a low (that is, less than the 789 * amount specified by the db-cleaner-min-utilization property) 790 * percentage of live data, moving the remaining live data to the end 791 * of the log and deleting that file. 792 * 793 * @return Returns the value of the "db-run-cleaner" property. 794 */ 795 boolean isDBRunCleaner(); 796 797 798 799 /** 800 * Sets the "db-run-cleaner" property. 801 * <p> 802 * Indicates whether the database cleaner threads should be enabled. 803 * <p> 804 * The cleaner threads are used to periodically compact the database 805 * by identifying database files with a low (that is, less than the 806 * amount specified by the db-cleaner-min-utilization property) 807 * percentage of live data, moving the remaining live data to the end 808 * of the log and deleting that file. 809 * 810 * @param value The value of the "db-run-cleaner" property. 811 * @throws PropertyException 812 * If the new value is invalid. 813 */ 814 void setDBRunCleaner(Boolean value) throws PropertyException; 815 816 817 818 /** 819 * Gets the "db-txn-no-sync" property. 820 * <p> 821 * Indicates whether database writes should be primarily written to 822 * an internal buffer but not immediately written to disk. 823 * <p> 824 * Setting the value of this configuration attribute to "true" may 825 * improve write performance but could cause the most recent changes 826 * to be lost if the OpenDJ directory server or the underlying JVM 827 * exits abnormally, or if an OS or hardware failure occurs (a 828 * behavior similar to running with transaction durability disabled 829 * in the Sun Java System Directory Server). 830 * 831 * @return Returns the value of the "db-txn-no-sync" property. 832 */ 833 boolean isDBTxnNoSync(); 834 835 836 837 /** 838 * Sets the "db-txn-no-sync" property. 839 * <p> 840 * Indicates whether database writes should be primarily written to 841 * an internal buffer but not immediately written to disk. 842 * <p> 843 * Setting the value of this configuration attribute to "true" may 844 * improve write performance but could cause the most recent changes 845 * to be lost if the OpenDJ directory server or the underlying JVM 846 * exits abnormally, or if an OS or hardware failure occurs (a 847 * behavior similar to running with transaction durability disabled 848 * in the Sun Java System Directory Server). 849 * 850 * @param value The value of the "db-txn-no-sync" property. 851 * @throws PropertyException 852 * If the new value is invalid. 853 */ 854 void setDBTxnNoSync(Boolean value) throws PropertyException; 855 856 857 858 /** 859 * Gets the "db-txn-write-no-sync" property. 860 * <p> 861 * Indicates whether the database should synchronously flush data as 862 * it is written to disk. 863 * <p> 864 * If this value is set to "false", then all data written to disk is 865 * synchronously flushed to persistent storage and thereby providing 866 * full durability. If it is set to "true", then data may be cached 867 * for a period of time by the underlying operating system before 868 * actually being written to disk. This may improve performance, but 869 * could cause the most recent changes to be lost in the event of an 870 * underlying OS or hardware failure (but not in the case that the 871 * OpenDJ directory server or the JVM exits abnormally). 872 * 873 * @return Returns the value of the "db-txn-write-no-sync" property. 874 */ 875 boolean isDBTxnWriteNoSync(); 876 877 878 879 /** 880 * Sets the "db-txn-write-no-sync" property. 881 * <p> 882 * Indicates whether the database should synchronously flush data as 883 * it is written to disk. 884 * <p> 885 * If this value is set to "false", then all data written to disk is 886 * synchronously flushed to persistent storage and thereby providing 887 * full durability. If it is set to "true", then data may be cached 888 * for a period of time by the underlying operating system before 889 * actually being written to disk. This may improve performance, but 890 * could cause the most recent changes to be lost in the event of an 891 * underlying OS or hardware failure (but not in the case that the 892 * OpenDJ directory server or the JVM exits abnormally). 893 * 894 * @param value The value of the "db-txn-write-no-sync" property. 895 * @throws PropertyException 896 * If the new value is invalid. 897 */ 898 void setDBTxnWriteNoSync(Boolean value) throws PropertyException; 899 900 901 902 /** 903 * Gets the "disk-full-threshold" property. 904 * <p> 905 * Full disk threshold to limit database updates 906 * <p> 907 * When the available free space on the disk used by this database 908 * instance falls below the value specified, no updates are permitted 909 * and the server returns an UNWILLING_TO_PERFORM error. Updates are 910 * allowed again as soon as free space rises above the threshold. 911 * 912 * @return Returns the value of the "disk-full-threshold" property. 913 */ 914 long getDiskFullThreshold(); 915 916 917 918 /** 919 * Sets the "disk-full-threshold" property. 920 * <p> 921 * Full disk threshold to limit database updates 922 * <p> 923 * When the available free space on the disk used by this database 924 * instance falls below the value specified, no updates are permitted 925 * and the server returns an UNWILLING_TO_PERFORM error. Updates are 926 * allowed again as soon as free space rises above the threshold. 927 * 928 * @param value The value of the "disk-full-threshold" property. 929 * @throws PropertyException 930 * If the new value is invalid. 931 */ 932 void setDiskFullThreshold(Long value) throws PropertyException; 933 934 935 936 /** 937 * Gets the "disk-low-threshold" property. 938 * <p> 939 * Low disk threshold to limit database updates 940 * <p> 941 * Specifies the "low" free space on the disk. When the available 942 * free space on the disk used by this database instance falls below 943 * the value specified, protocol updates on this database are 944 * permitted only by a user with the BYPASS_LOCKDOWN privilege. 945 * 946 * @return Returns the value of the "disk-low-threshold" property. 947 */ 948 long getDiskLowThreshold(); 949 950 951 952 /** 953 * Sets the "disk-low-threshold" property. 954 * <p> 955 * Low disk threshold to limit database updates 956 * <p> 957 * Specifies the "low" free space on the disk. When the available 958 * free space on the disk used by this database instance falls below 959 * the value specified, protocol updates on this database are 960 * permitted only by a user with the BYPASS_LOCKDOWN privilege. 961 * 962 * @param value The value of the "disk-low-threshold" property. 963 * @throws PropertyException 964 * If the new value is invalid. 965 */ 966 void setDiskLowThreshold(Long value) throws PropertyException; 967 968 969 970 /** 971 * Gets the "entries-compressed" property. 972 * <p> 973 * Indicates whether the backend should attempt to compress entries 974 * before storing them in the database. 975 * <p> 976 * Note that this property applies only to the entries themselves 977 * and does not impact the index data. Further, the effectiveness of 978 * the compression is based on the type of data contained in the 979 * entry. 980 * 981 * @return Returns the value of the "entries-compressed" property. 982 */ 983 boolean isEntriesCompressed(); 984 985 986 987 /** 988 * Sets the "entries-compressed" property. 989 * <p> 990 * Indicates whether the backend should attempt to compress entries 991 * before storing them in the database. 992 * <p> 993 * Note that this property applies only to the entries themselves 994 * and does not impact the index data. Further, the effectiveness of 995 * the compression is based on the type of data contained in the 996 * entry. 997 * 998 * @param value The value of the "entries-compressed" property. 999 * @throws PropertyException 1000 * If the new value is invalid. 1001 */ 1002 void setEntriesCompressed(Boolean value) throws PropertyException; 1003 1004 1005 1006 /** 1007 * Gets the "import-queue-size" property. 1008 * <p> 1009 * This parameter has been deprecated in OpenDS 2.1 and will be 1010 * removed in OpenDJ 3.0. It is only being kept for migration ease 1011 * and is ignored in OpenDS versions after 2.0. 1012 * 1013 * @return Returns the value of the "import-queue-size" property. 1014 */ 1015 int getImportQueueSize(); 1016 1017 1018 1019 /** 1020 * Sets the "import-queue-size" property. 1021 * <p> 1022 * This parameter has been deprecated in OpenDS 2.1 and will be 1023 * removed in OpenDJ 3.0. It is only being kept for migration ease 1024 * and is ignored in OpenDS versions after 2.0. 1025 * 1026 * @param value The value of the "import-queue-size" property. 1027 * @throws PropertyException 1028 * If the new value is invalid. 1029 */ 1030 void setImportQueueSize(Integer value) throws PropertyException; 1031 1032 1033 1034 /** 1035 * Gets the "import-thread-count" property. 1036 * <p> 1037 * This parameter has been deprecated in OpenDS 2.1 and will be 1038 * removed in OpenDJ 3.0. It is only being kept for migration ease 1039 * and is ignored in OpenDS versions after 2.0. 1040 * <p> 1041 * This parameter has been deprecated in OpenDS 2.1 and will be 1042 * removed in OpenDJ 3.0. It is only being kept for migration ease 1043 * and is ignored in OpenDS versions after 2.0. 1044 * 1045 * @return Returns the value of the "import-thread-count" property. 1046 */ 1047 int getImportThreadCount(); 1048 1049 1050 1051 /** 1052 * Sets the "import-thread-count" property. 1053 * <p> 1054 * This parameter has been deprecated in OpenDS 2.1 and will be 1055 * removed in OpenDJ 3.0. It is only being kept for migration ease 1056 * and is ignored in OpenDS versions after 2.0. 1057 * <p> 1058 * This parameter has been deprecated in OpenDS 2.1 and will be 1059 * removed in OpenDJ 3.0. It is only being kept for migration ease 1060 * and is ignored in OpenDS versions after 2.0. 1061 * 1062 * @param value The value of the "import-thread-count" property. 1063 * @throws PropertyException 1064 * If the new value is invalid. 1065 */ 1066 void setImportThreadCount(Integer value) throws PropertyException; 1067 1068 1069 1070 /** 1071 * Gets the "index-entry-limit" property. 1072 * <p> 1073 * Specifies the maximum number of entries that is allowed to match 1074 * a given index key before that particular index key is no longer 1075 * maintained. 1076 * <p> 1077 * This property is analogous to the ALL IDs threshold in the Sun 1078 * Java System Directory Server. Note that this is the default limit 1079 * for the backend, and it may be overridden on a per-attribute 1080 * basis.A value of 0 means there is no limit. 1081 * 1082 * @return Returns the value of the "index-entry-limit" property. 1083 */ 1084 int getIndexEntryLimit(); 1085 1086 1087 1088 /** 1089 * Sets the "index-entry-limit" property. 1090 * <p> 1091 * Specifies the maximum number of entries that is allowed to match 1092 * a given index key before that particular index key is no longer 1093 * maintained. 1094 * <p> 1095 * This property is analogous to the ALL IDs threshold in the Sun 1096 * Java System Directory Server. Note that this is the default limit 1097 * for the backend, and it may be overridden on a per-attribute 1098 * basis.A value of 0 means there is no limit. 1099 * 1100 * @param value The value of the "index-entry-limit" property. 1101 * @throws PropertyException 1102 * If the new value is invalid. 1103 */ 1104 void setIndexEntryLimit(Integer value) throws PropertyException; 1105 1106 1107 1108 /** 1109 * Gets the "index-filter-analyzer-enabled" property. 1110 * <p> 1111 * Indicates whether to gather statistical information about the 1112 * search filters processed by the directory server while evaluating 1113 * the usage of indexes. 1114 * <p> 1115 * Analyzing indexes requires gathering search filter usage patterns 1116 * from user requests, especially for values as specified in the 1117 * filters and subsequently looking the status of those values into 1118 * the index files. When a search requests is processed, internal or 1119 * user generated, a first phase uses indexes to find potential 1120 * entries to be returned. Depending on the search filter, if the 1121 * index of one of the specified attributes matches too many entries 1122 * (exceeds the index entry limit), the search becomes non-indexed. 1123 * In any case, all entries thus gathered (or the entire DIT) are 1124 * matched against the filter for actually returning the search 1125 * result. 1126 * 1127 * @return Returns the value of the "index-filter-analyzer-enabled" property. 1128 */ 1129 boolean isIndexFilterAnalyzerEnabled(); 1130 1131 1132 1133 /** 1134 * Sets the "index-filter-analyzer-enabled" property. 1135 * <p> 1136 * Indicates whether to gather statistical information about the 1137 * search filters processed by the directory server while evaluating 1138 * the usage of indexes. 1139 * <p> 1140 * Analyzing indexes requires gathering search filter usage patterns 1141 * from user requests, especially for values as specified in the 1142 * filters and subsequently looking the status of those values into 1143 * the index files. When a search requests is processed, internal or 1144 * user generated, a first phase uses indexes to find potential 1145 * entries to be returned. Depending on the search filter, if the 1146 * index of one of the specified attributes matches too many entries 1147 * (exceeds the index entry limit), the search becomes non-indexed. 1148 * In any case, all entries thus gathered (or the entire DIT) are 1149 * matched against the filter for actually returning the search 1150 * result. 1151 * 1152 * @param value The value of the "index-filter-analyzer-enabled" property. 1153 * @throws PropertyException 1154 * If the new value is invalid. 1155 */ 1156 void setIndexFilterAnalyzerEnabled(Boolean value) throws PropertyException; 1157 1158 1159 1160 /** 1161 * Gets the "index-filter-analyzer-max-filters" property. 1162 * <p> 1163 * The maximum number of search filter statistics to keep. 1164 * <p> 1165 * When the maximum number of search filter is reached, the least 1166 * used one will be deleted. 1167 * 1168 * @return Returns the value of the "index-filter-analyzer-max-filters" property. 1169 */ 1170 int getIndexFilterAnalyzerMaxFilters(); 1171 1172 1173 1174 /** 1175 * Sets the "index-filter-analyzer-max-filters" property. 1176 * <p> 1177 * The maximum number of search filter statistics to keep. 1178 * <p> 1179 * When the maximum number of search filter is reached, the least 1180 * used one will be deleted. 1181 * 1182 * @param value The value of the "index-filter-analyzer-max-filters" property. 1183 * @throws PropertyException 1184 * If the new value is invalid. 1185 */ 1186 void setIndexFilterAnalyzerMaxFilters(Integer value) throws PropertyException; 1187 1188 1189 1190 /** 1191 * Gets the "java-class" property. 1192 * <p> 1193 * Specifies the fully-qualified name of the Java class that 1194 * provides the backend implementation. 1195 * 1196 * @return Returns the value of the "java-class" property. 1197 */ 1198 String getJavaClass(); 1199 1200 1201 1202 /** 1203 * Sets the "java-class" property. 1204 * <p> 1205 * Specifies the fully-qualified name of the Java class that 1206 * provides the backend implementation. 1207 * 1208 * @param value The value of the "java-class" property. 1209 * @throws PropertyException 1210 * If the new value is invalid. 1211 */ 1212 void setJavaClass(String value) throws PropertyException; 1213 1214 1215 1216 /** 1217 * Gets the "je-property" property. 1218 * <p> 1219 * Specifies the database and environment properties for the 1220 * Berkeley DB Java Edition database serving the data for this 1221 * backend. 1222 * <p> 1223 * Any Berkeley DB Java Edition property can be specified using the 1224 * following form: property-name=property-value. Refer to OpenDJ 1225 * documentation for further information on related properties, their 1226 * implications, and range values. The definitive identification of 1227 * all the property parameters is available in the example.properties 1228 * file of Berkeley DB Java Edition distribution. 1229 * 1230 * @return Returns the values of the "je-property" property. 1231 */ 1232 SortedSet<String> getJEProperty(); 1233 1234 1235 1236 /** 1237 * Sets the "je-property" property. 1238 * <p> 1239 * Specifies the database and environment properties for the 1240 * Berkeley DB Java Edition database serving the data for this 1241 * backend. 1242 * <p> 1243 * Any Berkeley DB Java Edition property can be specified using the 1244 * following form: property-name=property-value. Refer to OpenDJ 1245 * documentation for further information on related properties, their 1246 * implications, and range values. The definitive identification of 1247 * all the property parameters is available in the example.properties 1248 * file of Berkeley DB Java Edition distribution. 1249 * 1250 * @param values The values of the "je-property" property. 1251 * @throws PropertyException 1252 * If one or more of the new values are invalid. 1253 */ 1254 void setJEProperty(Collection<String> values) throws PropertyException; 1255 1256 1257 1258 /** 1259 * Gets the "preload-time-limit" property. 1260 * <p> 1261 * Specifies the length of time that the backend is allowed to spend 1262 * "pre-loading" data when it is initialized. 1263 * <p> 1264 * The pre-load process is used to pre-populate the database cache, 1265 * so that it can be more quickly available when the server is 1266 * processing requests. A duration of zero means there is no 1267 * pre-load. 1268 * 1269 * @return Returns the value of the "preload-time-limit" property. 1270 */ 1271 long getPreloadTimeLimit(); 1272 1273 1274 1275 /** 1276 * Sets the "preload-time-limit" property. 1277 * <p> 1278 * Specifies the length of time that the backend is allowed to spend 1279 * "pre-loading" data when it is initialized. 1280 * <p> 1281 * The pre-load process is used to pre-populate the database cache, 1282 * so that it can be more quickly available when the server is 1283 * processing requests. A duration of zero means there is no 1284 * pre-load. 1285 * 1286 * @param value The value of the "preload-time-limit" property. 1287 * @throws PropertyException 1288 * If the new value is invalid. 1289 */ 1290 void setPreloadTimeLimit(Long value) throws PropertyException; 1291 1292 1293 1294 /** 1295 * Gets the "subordinate-indexes-enabled" property. 1296 * <p> 1297 * Indicates whether id2children and id2subtree indexes should be 1298 * used for this backend. These indexes are used for constraining 1299 * filtered searches to the search request's scope as well as for 1300 * generating values for the hasSubordinates and numSubordinates 1301 * virtual attributes. 1302 * <p> 1303 * Subordinate indexing is enabled by default and should only be 1304 * disabled for specialized use cases. A typical use case is where 1305 * the backend is to be subjected to heavy add/delete load beneath 1306 * the same parent entry such as when used as a session database. 1307 * Disabling the subordinate indexes means that the numSubordinates 1308 * and hasSubordinates virtual attributes will not be supported. 1309 * 1310 * @return Returns the value of the "subordinate-indexes-enabled" property. 1311 */ 1312 boolean isSubordinateIndexesEnabled(); 1313 1314 1315 1316 /** 1317 * Sets the "subordinate-indexes-enabled" property. 1318 * <p> 1319 * Indicates whether id2children and id2subtree indexes should be 1320 * used for this backend. These indexes are used for constraining 1321 * filtered searches to the search request's scope as well as for 1322 * generating values for the hasSubordinates and numSubordinates 1323 * virtual attributes. 1324 * <p> 1325 * Subordinate indexing is enabled by default and should only be 1326 * disabled for specialized use cases. A typical use case is where 1327 * the backend is to be subjected to heavy add/delete load beneath 1328 * the same parent entry such as when used as a session database. 1329 * Disabling the subordinate indexes means that the numSubordinates 1330 * and hasSubordinates virtual attributes will not be supported. 1331 * 1332 * @param value The value of the "subordinate-indexes-enabled" property. 1333 * @throws PropertyException 1334 * If the new value is invalid. 1335 */ 1336 void setSubordinateIndexesEnabled(Boolean value) throws PropertyException; 1337 1338 1339 1340 /** 1341 * Gets the "writability-mode" property. 1342 * <p> 1343 * Specifies the behavior that the backend should use when 1344 * processing write operations. 1345 * 1346 * @return Returns the value of the "writability-mode" property. 1347 */ 1348 WritabilityMode getWritabilityMode(); 1349 1350 1351 1352 /** 1353 * Sets the "writability-mode" property. 1354 * <p> 1355 * Specifies the behavior that the backend should use when 1356 * processing write operations. 1357 * 1358 * @param value The value of the "writability-mode" property. 1359 * @throws PropertyException 1360 * If the new value is invalid. 1361 */ 1362 void setWritabilityMode(WritabilityMode value) throws PropertyException; 1363 1364 1365 1366 /** 1367 * Lists the Local DB Indexes. 1368 * 1369 * @return Returns an array containing the names of the Local DB 1370 * Indexes. 1371 * @throws ConcurrentModificationException 1372 * If this Local DB Backend has been removed from the 1373 * server by another client. 1374 * @throws LdapException 1375 * If any other error occurs. 1376 */ 1377 String[] listLocalDBIndexes() throws ConcurrentModificationException, 1378 LdapException; 1379 1380 1381 1382 /** 1383 * Gets the named Local DB Index. 1384 * 1385 * @param name 1386 * The name of the Local DB Index to retrieve. 1387 * @return Returns the named Local DB Index. 1388 * @throws DefinitionDecodingException 1389 * If the named Local DB Index was found but its type 1390 * could not be determined. 1391 * @throws ManagedObjectDecodingException 1392 * If the named Local DB Index was found but one or more 1393 * of its properties could not be decoded. 1394 * @throws ManagedObjectNotFoundException 1395 * If the named Local DB Index was not found on the 1396 * server. 1397 * @throws ConcurrentModificationException 1398 * If this Local DB Backend has been removed from the 1399 * server by another client. 1400 * @throws LdapException 1401 * If any other error occurs. 1402 */ 1403 LocalDBIndexCfgClient getLocalDBIndex(String name) 1404 throws DefinitionDecodingException, ManagedObjectDecodingException, 1405 ManagedObjectNotFoundException, ConcurrentModificationException, 1406 LdapException; 1407 1408 1409 1410 /** 1411 * Creates a new Local DB Index. The new Local DB Index will 1412 * initially not contain any property values (including mandatory 1413 * properties). Once the Local DB Index has been configured it can be 1414 * added to the server using the {@link #commit()} method. 1415 * 1416 * @param <C> 1417 * The type of the Local DB Index being created. 1418 * @param d 1419 * The definition of the Local DB Index to be created. 1420 * @param name 1421 * The name of the new Local DB Index. 1422 * @param exceptions 1423 * An optional collection in which to place any {@link 1424 * PropertyException}s that occurred whilst attempting to 1425 * determine the default values of the Local DB Index. This 1426 * argument can be <code>null<code>. 1427 * @return Returns a new Local DB Index configuration instance. 1428 * @throws IllegalManagedObjectNameException 1429 * If the name of the new Local DB Index is invalid. 1430 */ 1431 <C extends LocalDBIndexCfgClient> C createLocalDBIndex( 1432 ManagedObjectDefinition<C, ? extends LocalDBIndexCfg> d, String name, Collection<PropertyException> exceptions) throws IllegalManagedObjectNameException; 1433 1434 1435 1436 /** 1437 * Removes the named Local DB Index. 1438 * 1439 * @param name 1440 * The name of the Local DB Index to remove. 1441 * @throws ManagedObjectNotFoundException 1442 * If the Local DB Index does not exist. 1443 * @throws OperationRejectedException 1444 * If the server refuses to remove the Local DB Index due 1445 * to some server-side constraint which cannot be satisfied 1446 * (for example, if it is referenced by another managed 1447 * object). 1448 * @throws ConcurrentModificationException 1449 * If this Local DB Backend has been removed from the 1450 * server by another client. 1451 * @throws LdapException 1452 * If any other error occurs. 1453 */ 1454 void removeLocalDBIndex(String name) 1455 throws ManagedObjectNotFoundException, OperationRejectedException, 1456 ConcurrentModificationException, LdapException; 1457 1458 1459 1460 /** 1461 * Lists the Local DB VLV Indexes. 1462 * 1463 * @return Returns an array containing the names of the Local DB VLV 1464 * Indexes. 1465 * @throws ConcurrentModificationException 1466 * If this Local DB Backend has been removed from the 1467 * server by another client. 1468 * @throws LdapException 1469 * If any other error occurs. 1470 */ 1471 String[] listLocalDBVLVIndexes() throws ConcurrentModificationException, 1472 LdapException; 1473 1474 1475 1476 /** 1477 * Gets the named Local DB VLV Index. 1478 * 1479 * @param name 1480 * The name of the Local DB VLV Index to retrieve. 1481 * @return Returns the named Local DB VLV Index. 1482 * @throws DefinitionDecodingException 1483 * If the named Local DB VLV Index was found but its type 1484 * could not be determined. 1485 * @throws ManagedObjectDecodingException 1486 * If the named Local DB VLV Index was found but one or 1487 * more of its properties could not be decoded. 1488 * @throws ManagedObjectNotFoundException 1489 * If the named Local DB VLV Index was not found on the 1490 * server. 1491 * @throws ConcurrentModificationException 1492 * If this Local DB Backend has been removed from the 1493 * server by another client. 1494 * @throws LdapException 1495 * If any other error occurs. 1496 */ 1497 LocalDBVLVIndexCfgClient getLocalDBVLVIndex(String name) 1498 throws DefinitionDecodingException, ManagedObjectDecodingException, 1499 ManagedObjectNotFoundException, ConcurrentModificationException, 1500 LdapException; 1501 1502 1503 1504 /** 1505 * Creates a new Local DB VLV Index. The new Local DB VLV Index will 1506 * initially not contain any property values (including mandatory 1507 * properties). Once the Local DB VLV Index has been configured it 1508 * can be added to the server using the {@link #commit()} method. 1509 * 1510 * @param <C> 1511 * The type of the Local DB VLV Index being created. 1512 * @param d 1513 * The definition of the Local DB VLV Index to be created. 1514 * @param name 1515 * The name of the new Local DB VLV Index. 1516 * @param exceptions 1517 * An optional collection in which to place any {@link 1518 * PropertyException}s that occurred whilst attempting to 1519 * determine the default values of the Local DB VLV Index. 1520 * This argument can be <code>null<code>. 1521 * @return Returns a new Local DB VLV Index configuration instance. 1522 * @throws IllegalManagedObjectNameException 1523 * If the name of the new Local DB VLV Index is invalid. 1524 */ 1525 <C extends LocalDBVLVIndexCfgClient> C createLocalDBVLVIndex( 1526 ManagedObjectDefinition<C, ? extends LocalDBVLVIndexCfg> d, String name, Collection<PropertyException> exceptions) throws IllegalManagedObjectNameException; 1527 1528 1529 1530 /** 1531 * Removes the named Local DB VLV Index. 1532 * 1533 * @param name 1534 * The name of the Local DB VLV Index to remove. 1535 * @throws ManagedObjectNotFoundException 1536 * If the Local DB VLV Index does not exist. 1537 * @throws OperationRejectedException 1538 * If the server refuses to remove the Local DB VLV Index 1539 * due to some server-side constraint which cannot be 1540 * satisfied (for example, if it is referenced by another 1541 * managed object). 1542 * @throws ConcurrentModificationException 1543 * If this Local DB Backend has been removed from the 1544 * server by another client. 1545 * @throws LdapException 1546 * If any other error occurs. 1547 */ 1548 void removeLocalDBVLVIndex(String name) 1549 throws ManagedObjectNotFoundException, OperationRejectedException, 1550 ConcurrentModificationException, LdapException; 1551 1552}