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