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