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