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