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.meta;
027
028
029
030import java.util.Collection;
031import java.util.SortedSet;
032import org.forgerock.opendj.config.AdministratorAction;
033import org.forgerock.opendj.config.AliasDefaultBehaviorProvider;
034import org.forgerock.opendj.config.BooleanPropertyDefinition;
035import org.forgerock.opendj.config.ClassPropertyDefinition;
036import org.forgerock.opendj.config.client.ConcurrentModificationException;
037import org.forgerock.opendj.config.client.IllegalManagedObjectNameException;
038import org.forgerock.opendj.config.client.ManagedObject;
039import org.forgerock.opendj.config.client.ManagedObjectDecodingException;
040import org.forgerock.opendj.config.client.MissingMandatoryPropertiesException;
041import org.forgerock.opendj.config.client.OperationRejectedException;
042import org.forgerock.opendj.config.conditions.Conditions;
043import org.forgerock.opendj.config.DefaultBehaviorProvider;
044import org.forgerock.opendj.config.DefaultManagedObject;
045import org.forgerock.opendj.config.DefinedDefaultBehaviorProvider;
046import org.forgerock.opendj.config.DefinitionDecodingException;
047import org.forgerock.opendj.config.DNPropertyDefinition;
048import org.forgerock.opendj.config.DurationPropertyDefinition;
049import org.forgerock.opendj.config.EnumPropertyDefinition;
050import org.forgerock.opendj.config.GenericConstraint;
051import org.forgerock.opendj.config.InstantiableRelationDefinition;
052import org.forgerock.opendj.config.IntegerPropertyDefinition;
053import org.forgerock.opendj.config.ManagedObjectAlreadyExistsException;
054import org.forgerock.opendj.config.ManagedObjectDefinition;
055import org.forgerock.opendj.config.ManagedObjectNotFoundException;
056import org.forgerock.opendj.config.PropertyException;
057import org.forgerock.opendj.config.PropertyOption;
058import org.forgerock.opendj.config.PropertyProvider;
059import org.forgerock.opendj.config.server.ConfigException;
060import org.forgerock.opendj.config.server.ConfigurationAddListener;
061import org.forgerock.opendj.config.server.ConfigurationChangeListener;
062import org.forgerock.opendj.config.server.ConfigurationDeleteListener;
063import org.forgerock.opendj.config.server.ServerManagedObject;
064import org.forgerock.opendj.config.SizePropertyDefinition;
065import org.forgerock.opendj.config.StringPropertyDefinition;
066import org.forgerock.opendj.config.Tag;
067import org.forgerock.opendj.config.UndefinedDefaultBehaviorProvider;
068import org.forgerock.opendj.ldap.DN;
069import org.forgerock.opendj.ldap.LdapException;
070import org.forgerock.opendj.server.config.client.LocalDBBackendCfgClient;
071import org.forgerock.opendj.server.config.client.LocalDBIndexCfgClient;
072import org.forgerock.opendj.server.config.client.LocalDBVLVIndexCfgClient;
073import org.forgerock.opendj.server.config.meta.BackendCfgDefn.WritabilityMode;
074import org.forgerock.opendj.server.config.meta.LocalDBIndexCfgDefn;
075import org.forgerock.opendj.server.config.server.BackendCfg;
076import org.forgerock.opendj.server.config.server.LocalDBBackendCfg;
077import org.forgerock.opendj.server.config.server.LocalDBIndexCfg;
078import org.forgerock.opendj.server.config.server.LocalDBVLVIndexCfg;
079
080
081
082/**
083 * An interface for querying the Local DB Backend managed object
084 * definition meta information.
085 * <p>
086 * The Local DB Backend uses the Berkeley DB Java Edition to store
087 * user-provided data in a local repository.
088 */
089public final class LocalDBBackendCfgDefn extends ManagedObjectDefinition<LocalDBBackendCfgClient, LocalDBBackendCfg> {
090
091  // The singleton configuration definition instance.
092  private static final LocalDBBackendCfgDefn INSTANCE = new LocalDBBackendCfgDefn();
093
094
095
096  // The "compact-encoding" property definition.
097  private static final BooleanPropertyDefinition PD_COMPACT_ENCODING;
098
099
100
101  // The "db-cache-percent" property definition.
102  private static final IntegerPropertyDefinition PD_DB_CACHE_PERCENT;
103
104
105
106  // The "db-cache-size" property definition.
107  private static final SizePropertyDefinition PD_DB_CACHE_SIZE;
108
109
110
111  // The "db-checkpointer-bytes-interval" property definition.
112  private static final SizePropertyDefinition PD_DB_CHECKPOINTER_BYTES_INTERVAL;
113
114
115
116  // The "db-checkpointer-wakeup-interval" property definition.
117  private static final DurationPropertyDefinition PD_DB_CHECKPOINTER_WAKEUP_INTERVAL;
118
119
120
121  // The "db-cleaner-min-utilization" property definition.
122  private static final IntegerPropertyDefinition PD_DB_CLEANER_MIN_UTILIZATION;
123
124
125
126  // The "db-directory" property definition.
127  private static final StringPropertyDefinition PD_DB_DIRECTORY;
128
129
130
131  // The "db-directory-permissions" property definition.
132  private static final StringPropertyDefinition PD_DB_DIRECTORY_PERMISSIONS;
133
134
135
136  // The "db-evictor-core-threads" property definition.
137  private static final IntegerPropertyDefinition PD_DB_EVICTOR_CORE_THREADS;
138
139
140
141  // The "db-evictor-keep-alive" property definition.
142  private static final DurationPropertyDefinition PD_DB_EVICTOR_KEEP_ALIVE;
143
144
145
146  // The "db-evictor-lru-only" property definition.
147  private static final BooleanPropertyDefinition PD_DB_EVICTOR_LRU_ONLY;
148
149
150
151  // The "db-evictor-max-threads" property definition.
152  private static final IntegerPropertyDefinition PD_DB_EVICTOR_MAX_THREADS;
153
154
155
156  // The "db-evictor-nodes-per-scan" property definition.
157  private static final IntegerPropertyDefinition PD_DB_EVICTOR_NODES_PER_SCAN;
158
159
160
161  // The "db-log-filecache-size" property definition.
162  private static final IntegerPropertyDefinition PD_DB_LOG_FILECACHE_SIZE;
163
164
165
166  // The "db-log-file-max" property definition.
167  private static final SizePropertyDefinition PD_DB_LOG_FILE_MAX;
168
169
170
171  // The "db-logging-file-handler-on" property definition.
172  private static final BooleanPropertyDefinition PD_DB_LOGGING_FILE_HANDLER_ON;
173
174
175
176  // The "db-logging-level" property definition.
177  private static final StringPropertyDefinition PD_DB_LOGGING_LEVEL;
178
179
180
181  // The "db-num-cleaner-threads" property definition.
182  private static final IntegerPropertyDefinition PD_DB_NUM_CLEANER_THREADS;
183
184
185
186  // The "db-num-lock-tables" property definition.
187  private static final IntegerPropertyDefinition PD_DB_NUM_LOCK_TABLES;
188
189
190
191  // The "db-run-cleaner" property definition.
192  private static final BooleanPropertyDefinition PD_DB_RUN_CLEANER;
193
194
195
196  // The "db-txn-no-sync" property definition.
197  private static final BooleanPropertyDefinition PD_DB_TXN_NO_SYNC;
198
199
200
201  // The "db-txn-write-no-sync" property definition.
202  private static final BooleanPropertyDefinition PD_DB_TXN_WRITE_NO_SYNC;
203
204
205
206  // The "disk-full-threshold" property definition.
207  private static final SizePropertyDefinition PD_DISK_FULL_THRESHOLD;
208
209
210
211  // The "disk-low-threshold" property definition.
212  private static final SizePropertyDefinition PD_DISK_LOW_THRESHOLD;
213
214
215
216  // The "entries-compressed" property definition.
217  private static final BooleanPropertyDefinition PD_ENTRIES_COMPRESSED;
218
219
220
221  // The "import-queue-size" property definition.
222  private static final IntegerPropertyDefinition PD_IMPORT_QUEUE_SIZE;
223
224
225
226  // The "import-thread-count" property definition.
227  private static final IntegerPropertyDefinition PD_IMPORT_THREAD_COUNT;
228
229
230
231  // The "index-entry-limit" property definition.
232  private static final IntegerPropertyDefinition PD_INDEX_ENTRY_LIMIT;
233
234
235
236  // The "index-filter-analyzer-enabled" property definition.
237  private static final BooleanPropertyDefinition PD_INDEX_FILTER_ANALYZER_ENABLED;
238
239
240
241  // The "index-filter-analyzer-max-filters" property definition.
242  private static final IntegerPropertyDefinition PD_INDEX_FILTER_ANALYZER_MAX_FILTERS;
243
244
245
246  // The "java-class" property definition.
247  private static final ClassPropertyDefinition PD_JAVA_CLASS;
248
249
250
251  // The "je-property" property definition.
252  private static final StringPropertyDefinition PD_JE_PROPERTY;
253
254
255
256  // The "preload-time-limit" property definition.
257  private static final DurationPropertyDefinition PD_PRELOAD_TIME_LIMIT;
258
259
260
261  // The "subordinate-indexes-enabled" property definition.
262  private static final BooleanPropertyDefinition PD_SUBORDINATE_INDEXES_ENABLED;
263
264
265
266  // The "writability-mode" property definition.
267  private static final EnumPropertyDefinition<WritabilityMode> PD_WRITABILITY_MODE;
268
269
270
271  // The "local-db-indexes" relation definition.
272  private static final InstantiableRelationDefinition<LocalDBIndexCfgClient, LocalDBIndexCfg> RD_LOCAL_DB_INDEXES;
273
274
275
276  // The "local-db-vlv-indexes" relation definition.
277  private static final InstantiableRelationDefinition<LocalDBVLVIndexCfgClient, LocalDBVLVIndexCfg> RD_LOCAL_DB_VLV_INDEXES;
278
279
280
281  // Build the "compact-encoding" property definition.
282  static {
283      BooleanPropertyDefinition.Builder builder = BooleanPropertyDefinition.createBuilder(INSTANCE, "compact-encoding");
284      builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "compact-encoding"));
285      DefaultBehaviorProvider<Boolean> provider = new DefinedDefaultBehaviorProvider<Boolean>("true");
286      builder.setDefaultBehaviorProvider(provider);
287      PD_COMPACT_ENCODING = builder.getInstance();
288      INSTANCE.registerPropertyDefinition(PD_COMPACT_ENCODING);
289  }
290
291
292
293  // Build the "db-cache-percent" property definition.
294  static {
295      IntegerPropertyDefinition.Builder builder = IntegerPropertyDefinition.createBuilder(INSTANCE, "db-cache-percent");
296      builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "db-cache-percent"));
297      DefaultBehaviorProvider<Integer> provider = new DefinedDefaultBehaviorProvider<Integer>("50");
298      builder.setDefaultBehaviorProvider(provider);
299      builder.setUpperLimit(90);
300      builder.setLowerLimit(1);
301      PD_DB_CACHE_PERCENT = builder.getInstance();
302      INSTANCE.registerPropertyDefinition(PD_DB_CACHE_PERCENT);
303  }
304
305
306
307  // Build the "db-cache-size" property definition.
308  static {
309      SizePropertyDefinition.Builder builder = SizePropertyDefinition.createBuilder(INSTANCE, "db-cache-size");
310      builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "db-cache-size"));
311      DefaultBehaviorProvider<Long> provider = new DefinedDefaultBehaviorProvider<Long>("0 MB");
312      builder.setDefaultBehaviorProvider(provider);
313      builder.setLowerLimit("0 MB");
314      PD_DB_CACHE_SIZE = builder.getInstance();
315      INSTANCE.registerPropertyDefinition(PD_DB_CACHE_SIZE);
316  }
317
318
319
320  // Build the "db-checkpointer-bytes-interval" property definition.
321  static {
322      SizePropertyDefinition.Builder builder = SizePropertyDefinition.createBuilder(INSTANCE, "db-checkpointer-bytes-interval");
323      builder.setOption(PropertyOption.ADVANCED);
324      builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.SERVER_RESTART, INSTANCE, "db-checkpointer-bytes-interval"));
325      DefaultBehaviorProvider<Long> provider = new DefinedDefaultBehaviorProvider<Long>("500mb");
326      builder.setDefaultBehaviorProvider(provider);
327      builder.setUpperLimit("9223372036854775807b");
328      builder.setLowerLimit("0b");
329      PD_DB_CHECKPOINTER_BYTES_INTERVAL = builder.getInstance();
330      INSTANCE.registerPropertyDefinition(PD_DB_CHECKPOINTER_BYTES_INTERVAL);
331  }
332
333
334
335  // Build the "db-checkpointer-wakeup-interval" property definition.
336  static {
337      DurationPropertyDefinition.Builder builder = DurationPropertyDefinition.createBuilder(INSTANCE, "db-checkpointer-wakeup-interval");
338      builder.setOption(PropertyOption.ADVANCED);
339      builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.COMPONENT_RESTART, INSTANCE, "db-checkpointer-wakeup-interval"));
340      DefaultBehaviorProvider<Long> provider = new DefinedDefaultBehaviorProvider<Long>("30s");
341      builder.setDefaultBehaviorProvider(provider);
342      builder.setBaseUnit("s");
343      builder.setUpperLimit("4294");
344      builder.setLowerLimit("1");
345      PD_DB_CHECKPOINTER_WAKEUP_INTERVAL = builder.getInstance();
346      INSTANCE.registerPropertyDefinition(PD_DB_CHECKPOINTER_WAKEUP_INTERVAL);
347  }
348
349
350
351  // Build the "db-cleaner-min-utilization" property definition.
352  static {
353      IntegerPropertyDefinition.Builder builder = IntegerPropertyDefinition.createBuilder(INSTANCE, "db-cleaner-min-utilization");
354      builder.setOption(PropertyOption.ADVANCED);
355      builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "db-cleaner-min-utilization"));
356      DefaultBehaviorProvider<Integer> provider = new DefinedDefaultBehaviorProvider<Integer>("50");
357      builder.setDefaultBehaviorProvider(provider);
358      builder.setUpperLimit(90);
359      builder.setLowerLimit(0);
360      PD_DB_CLEANER_MIN_UTILIZATION = builder.getInstance();
361      INSTANCE.registerPropertyDefinition(PD_DB_CLEANER_MIN_UTILIZATION);
362  }
363
364
365
366  // Build the "db-directory" property definition.
367  static {
368      StringPropertyDefinition.Builder builder = StringPropertyDefinition.createBuilder(INSTANCE, "db-directory");
369      builder.setOption(PropertyOption.MANDATORY);
370      builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.COMPONENT_RESTART, INSTANCE, "db-directory"));
371      DefaultBehaviorProvider<String> provider = new DefinedDefaultBehaviorProvider<String>("db");
372      builder.setDefaultBehaviorProvider(provider);
373      PD_DB_DIRECTORY = builder.getInstance();
374      INSTANCE.registerPropertyDefinition(PD_DB_DIRECTORY);
375  }
376
377
378
379  // Build the "db-directory-permissions" property definition.
380  static {
381      StringPropertyDefinition.Builder builder = StringPropertyDefinition.createBuilder(INSTANCE, "db-directory-permissions");
382      builder.setOption(PropertyOption.ADVANCED);
383      builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.SERVER_RESTART, INSTANCE, "db-directory-permissions"));
384      DefaultBehaviorProvider<String> provider = new DefinedDefaultBehaviorProvider<String>("700");
385      builder.setDefaultBehaviorProvider(provider);
386      builder.setPattern("^7[0-7][0-7]$", "MODE");
387      PD_DB_DIRECTORY_PERMISSIONS = builder.getInstance();
388      INSTANCE.registerPropertyDefinition(PD_DB_DIRECTORY_PERMISSIONS);
389  }
390
391
392
393  // Build the "db-evictor-core-threads" property definition.
394  static {
395      IntegerPropertyDefinition.Builder builder = IntegerPropertyDefinition.createBuilder(INSTANCE, "db-evictor-core-threads");
396      builder.setOption(PropertyOption.ADVANCED);
397      builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "db-evictor-core-threads"));
398      DefaultBehaviorProvider<Integer> provider = new DefinedDefaultBehaviorProvider<Integer>("1");
399      builder.setDefaultBehaviorProvider(provider);
400      builder.setUpperLimit(2147483647);
401      builder.setLowerLimit(0);
402      PD_DB_EVICTOR_CORE_THREADS = builder.getInstance();
403      INSTANCE.registerPropertyDefinition(PD_DB_EVICTOR_CORE_THREADS);
404  }
405
406
407
408  // Build the "db-evictor-keep-alive" property definition.
409  static {
410      DurationPropertyDefinition.Builder builder = DurationPropertyDefinition.createBuilder(INSTANCE, "db-evictor-keep-alive");
411      builder.setOption(PropertyOption.ADVANCED);
412      builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "db-evictor-keep-alive"));
413      DefaultBehaviorProvider<Long> provider = new DefinedDefaultBehaviorProvider<Long>("600s");
414      builder.setDefaultBehaviorProvider(provider);
415      builder.setBaseUnit("s");
416      builder.setUpperLimit("86400");
417      builder.setLowerLimit("1");
418      PD_DB_EVICTOR_KEEP_ALIVE = builder.getInstance();
419      INSTANCE.registerPropertyDefinition(PD_DB_EVICTOR_KEEP_ALIVE);
420  }
421
422
423
424  // Build the "db-evictor-lru-only" property definition.
425  static {
426      BooleanPropertyDefinition.Builder builder = BooleanPropertyDefinition.createBuilder(INSTANCE, "db-evictor-lru-only");
427      builder.setOption(PropertyOption.ADVANCED);
428      builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.COMPONENT_RESTART, INSTANCE, "db-evictor-lru-only"));
429      DefaultBehaviorProvider<Boolean> provider = new DefinedDefaultBehaviorProvider<Boolean>("false");
430      builder.setDefaultBehaviorProvider(provider);
431      PD_DB_EVICTOR_LRU_ONLY = builder.getInstance();
432      INSTANCE.registerPropertyDefinition(PD_DB_EVICTOR_LRU_ONLY);
433  }
434
435
436
437  // Build the "db-evictor-max-threads" property definition.
438  static {
439      IntegerPropertyDefinition.Builder builder = IntegerPropertyDefinition.createBuilder(INSTANCE, "db-evictor-max-threads");
440      builder.setOption(PropertyOption.ADVANCED);
441      builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "db-evictor-max-threads"));
442      DefaultBehaviorProvider<Integer> provider = new DefinedDefaultBehaviorProvider<Integer>("10");
443      builder.setDefaultBehaviorProvider(provider);
444      builder.setUpperLimit(2147483647);
445      builder.setLowerLimit(1);
446      PD_DB_EVICTOR_MAX_THREADS = builder.getInstance();
447      INSTANCE.registerPropertyDefinition(PD_DB_EVICTOR_MAX_THREADS);
448  }
449
450
451
452  // Build the "db-evictor-nodes-per-scan" property definition.
453  static {
454      IntegerPropertyDefinition.Builder builder = IntegerPropertyDefinition.createBuilder(INSTANCE, "db-evictor-nodes-per-scan");
455      builder.setOption(PropertyOption.ADVANCED);
456      builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.COMPONENT_RESTART, INSTANCE, "db-evictor-nodes-per-scan"));
457      DefaultBehaviorProvider<Integer> provider = new DefinedDefaultBehaviorProvider<Integer>("10");
458      builder.setDefaultBehaviorProvider(provider);
459      builder.setUpperLimit(1000);
460      builder.setLowerLimit(1);
461      PD_DB_EVICTOR_NODES_PER_SCAN = builder.getInstance();
462      INSTANCE.registerPropertyDefinition(PD_DB_EVICTOR_NODES_PER_SCAN);
463  }
464
465
466
467  // Build the "db-log-filecache-size" property definition.
468  static {
469      IntegerPropertyDefinition.Builder builder = IntegerPropertyDefinition.createBuilder(INSTANCE, "db-log-filecache-size");
470      builder.setOption(PropertyOption.ADVANCED);
471      builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.COMPONENT_RESTART, INSTANCE, "db-log-filecache-size"));
472      DefaultBehaviorProvider<Integer> provider = new DefinedDefaultBehaviorProvider<Integer>("100");
473      builder.setDefaultBehaviorProvider(provider);
474      builder.setUpperLimit(2147483647);
475      builder.setLowerLimit(3);
476      PD_DB_LOG_FILECACHE_SIZE = builder.getInstance();
477      INSTANCE.registerPropertyDefinition(PD_DB_LOG_FILECACHE_SIZE);
478  }
479
480
481
482  // Build the "db-log-file-max" property definition.
483  static {
484      SizePropertyDefinition.Builder builder = SizePropertyDefinition.createBuilder(INSTANCE, "db-log-file-max");
485      builder.setOption(PropertyOption.ADVANCED);
486      builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.COMPONENT_RESTART, INSTANCE, "db-log-file-max"));
487      DefaultBehaviorProvider<Long> provider = new DefinedDefaultBehaviorProvider<Long>("100mb");
488      builder.setDefaultBehaviorProvider(provider);
489      builder.setUpperLimit("4gib");
490      builder.setLowerLimit("1mb");
491      PD_DB_LOG_FILE_MAX = builder.getInstance();
492      INSTANCE.registerPropertyDefinition(PD_DB_LOG_FILE_MAX);
493  }
494
495
496
497  // Build the "db-logging-file-handler-on" property definition.
498  static {
499      BooleanPropertyDefinition.Builder builder = BooleanPropertyDefinition.createBuilder(INSTANCE, "db-logging-file-handler-on");
500      builder.setOption(PropertyOption.ADVANCED);
501      builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.COMPONENT_RESTART, INSTANCE, "db-logging-file-handler-on"));
502      DefaultBehaviorProvider<Boolean> provider = new DefinedDefaultBehaviorProvider<Boolean>("true");
503      builder.setDefaultBehaviorProvider(provider);
504      PD_DB_LOGGING_FILE_HANDLER_ON = builder.getInstance();
505      INSTANCE.registerPropertyDefinition(PD_DB_LOGGING_FILE_HANDLER_ON);
506  }
507
508
509
510  // Build the "db-logging-level" property definition.
511  static {
512      StringPropertyDefinition.Builder builder = StringPropertyDefinition.createBuilder(INSTANCE, "db-logging-level");
513      builder.setOption(PropertyOption.ADVANCED);
514      builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.COMPONENT_RESTART, INSTANCE, "db-logging-level"));
515      DefaultBehaviorProvider<String> provider = new DefinedDefaultBehaviorProvider<String>("CONFIG");
516      builder.setDefaultBehaviorProvider(provider);
517      PD_DB_LOGGING_LEVEL = builder.getInstance();
518      INSTANCE.registerPropertyDefinition(PD_DB_LOGGING_LEVEL);
519  }
520
521
522
523  // Build the "db-num-cleaner-threads" property definition.
524  static {
525      IntegerPropertyDefinition.Builder builder = IntegerPropertyDefinition.createBuilder(INSTANCE, "db-num-cleaner-threads");
526      builder.setOption(PropertyOption.ADVANCED);
527      builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "db-num-cleaner-threads"));
528      builder.setDefaultBehaviorProvider(new AliasDefaultBehaviorProvider<Integer>(INSTANCE, "db-num-cleaner-threads"));
529      builder.setLowerLimit(1);
530      PD_DB_NUM_CLEANER_THREADS = builder.getInstance();
531      INSTANCE.registerPropertyDefinition(PD_DB_NUM_CLEANER_THREADS);
532  }
533
534
535
536  // Build the "db-num-lock-tables" property definition.
537  static {
538      IntegerPropertyDefinition.Builder builder = IntegerPropertyDefinition.createBuilder(INSTANCE, "db-num-lock-tables");
539      builder.setOption(PropertyOption.ADVANCED);
540      builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.COMPONENT_RESTART, INSTANCE, "db-num-lock-tables"));
541      builder.setDefaultBehaviorProvider(new AliasDefaultBehaviorProvider<Integer>(INSTANCE, "db-num-lock-tables"));
542      builder.setUpperLimit(32767);
543      builder.setLowerLimit(1);
544      PD_DB_NUM_LOCK_TABLES = builder.getInstance();
545      INSTANCE.registerPropertyDefinition(PD_DB_NUM_LOCK_TABLES);
546  }
547
548
549
550  // Build the "db-run-cleaner" property definition.
551  static {
552      BooleanPropertyDefinition.Builder builder = BooleanPropertyDefinition.createBuilder(INSTANCE, "db-run-cleaner");
553      builder.setOption(PropertyOption.ADVANCED);
554      builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "db-run-cleaner"));
555      DefaultBehaviorProvider<Boolean> provider = new DefinedDefaultBehaviorProvider<Boolean>("true");
556      builder.setDefaultBehaviorProvider(provider);
557      PD_DB_RUN_CLEANER = builder.getInstance();
558      INSTANCE.registerPropertyDefinition(PD_DB_RUN_CLEANER);
559  }
560
561
562
563  // Build the "db-txn-no-sync" property definition.
564  static {
565      BooleanPropertyDefinition.Builder builder = BooleanPropertyDefinition.createBuilder(INSTANCE, "db-txn-no-sync");
566      builder.setOption(PropertyOption.ADVANCED);
567      builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "db-txn-no-sync"));
568      DefaultBehaviorProvider<Boolean> provider = new DefinedDefaultBehaviorProvider<Boolean>("false");
569      builder.setDefaultBehaviorProvider(provider);
570      PD_DB_TXN_NO_SYNC = builder.getInstance();
571      INSTANCE.registerPropertyDefinition(PD_DB_TXN_NO_SYNC);
572  }
573
574
575
576  // Build the "db-txn-write-no-sync" property definition.
577  static {
578      BooleanPropertyDefinition.Builder builder = BooleanPropertyDefinition.createBuilder(INSTANCE, "db-txn-write-no-sync");
579      builder.setOption(PropertyOption.ADVANCED);
580      builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "db-txn-write-no-sync"));
581      DefaultBehaviorProvider<Boolean> provider = new DefinedDefaultBehaviorProvider<Boolean>("true");
582      builder.setDefaultBehaviorProvider(provider);
583      PD_DB_TXN_WRITE_NO_SYNC = builder.getInstance();
584      INSTANCE.registerPropertyDefinition(PD_DB_TXN_WRITE_NO_SYNC);
585  }
586
587
588
589  // Build the "disk-full-threshold" property definition.
590  static {
591      SizePropertyDefinition.Builder builder = SizePropertyDefinition.createBuilder(INSTANCE, "disk-full-threshold");
592      builder.setOption(PropertyOption.ADVANCED);
593      builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "disk-full-threshold"));
594      DefaultBehaviorProvider<Long> provider = new DefinedDefaultBehaviorProvider<Long>("100 megabytes");
595      builder.setDefaultBehaviorProvider(provider);
596      builder.setLowerLimit("0");
597      PD_DISK_FULL_THRESHOLD = builder.getInstance();
598      INSTANCE.registerPropertyDefinition(PD_DISK_FULL_THRESHOLD);
599  }
600
601
602
603  // Build the "disk-low-threshold" property definition.
604  static {
605      SizePropertyDefinition.Builder builder = SizePropertyDefinition.createBuilder(INSTANCE, "disk-low-threshold");
606      builder.setOption(PropertyOption.ADVANCED);
607      builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "disk-low-threshold"));
608      DefaultBehaviorProvider<Long> provider = new DefinedDefaultBehaviorProvider<Long>("200 megabytes");
609      builder.setDefaultBehaviorProvider(provider);
610      builder.setLowerLimit("0");
611      PD_DISK_LOW_THRESHOLD = builder.getInstance();
612      INSTANCE.registerPropertyDefinition(PD_DISK_LOW_THRESHOLD);
613  }
614
615
616
617  // Build the "entries-compressed" property definition.
618  static {
619      BooleanPropertyDefinition.Builder builder = BooleanPropertyDefinition.createBuilder(INSTANCE, "entries-compressed");
620      builder.setOption(PropertyOption.ADVANCED);
621      builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "entries-compressed"));
622      DefaultBehaviorProvider<Boolean> provider = new DefinedDefaultBehaviorProvider<Boolean>("false");
623      builder.setDefaultBehaviorProvider(provider);
624      PD_ENTRIES_COMPRESSED = builder.getInstance();
625      INSTANCE.registerPropertyDefinition(PD_ENTRIES_COMPRESSED);
626  }
627
628
629
630  // Build the "import-queue-size" property definition.
631  static {
632      IntegerPropertyDefinition.Builder builder = IntegerPropertyDefinition.createBuilder(INSTANCE, "import-queue-size");
633      builder.setOption(PropertyOption.ADVANCED);
634      builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "import-queue-size"));
635      DefaultBehaviorProvider<Integer> provider = new DefinedDefaultBehaviorProvider<Integer>("100");
636      builder.setDefaultBehaviorProvider(provider);
637      builder.setUpperLimit(2147483647);
638      builder.setLowerLimit(1);
639      PD_IMPORT_QUEUE_SIZE = builder.getInstance();
640      INSTANCE.registerPropertyDefinition(PD_IMPORT_QUEUE_SIZE);
641  }
642
643
644
645  // Build the "import-thread-count" property definition.
646  static {
647      IntegerPropertyDefinition.Builder builder = IntegerPropertyDefinition.createBuilder(INSTANCE, "import-thread-count");
648      builder.setOption(PropertyOption.ADVANCED);
649      builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "import-thread-count"));
650      DefaultBehaviorProvider<Integer> provider = new DefinedDefaultBehaviorProvider<Integer>("8");
651      builder.setDefaultBehaviorProvider(provider);
652      builder.setUpperLimit(2147483647);
653      builder.setLowerLimit(1);
654      PD_IMPORT_THREAD_COUNT = builder.getInstance();
655      INSTANCE.registerPropertyDefinition(PD_IMPORT_THREAD_COUNT);
656  }
657
658
659
660  // Build the "index-entry-limit" property definition.
661  static {
662      IntegerPropertyDefinition.Builder builder = IntegerPropertyDefinition.createBuilder(INSTANCE, "index-entry-limit");
663      builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "index-entry-limit"));
664      DefaultBehaviorProvider<Integer> provider = new DefinedDefaultBehaviorProvider<Integer>("4000");
665      builder.setDefaultBehaviorProvider(provider);
666      builder.setUpperLimit(2147483647);
667      builder.setLowerLimit(0);
668      PD_INDEX_ENTRY_LIMIT = builder.getInstance();
669      INSTANCE.registerPropertyDefinition(PD_INDEX_ENTRY_LIMIT);
670  }
671
672
673
674  // Build the "index-filter-analyzer-enabled" property definition.
675  static {
676      BooleanPropertyDefinition.Builder builder = BooleanPropertyDefinition.createBuilder(INSTANCE, "index-filter-analyzer-enabled");
677      builder.setOption(PropertyOption.ADVANCED);
678      builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "index-filter-analyzer-enabled"));
679      DefaultBehaviorProvider<Boolean> provider = new DefinedDefaultBehaviorProvider<Boolean>("false");
680      builder.setDefaultBehaviorProvider(provider);
681      PD_INDEX_FILTER_ANALYZER_ENABLED = builder.getInstance();
682      INSTANCE.registerPropertyDefinition(PD_INDEX_FILTER_ANALYZER_ENABLED);
683  }
684
685
686
687  // Build the "index-filter-analyzer-max-filters" property definition.
688  static {
689      IntegerPropertyDefinition.Builder builder = IntegerPropertyDefinition.createBuilder(INSTANCE, "index-filter-analyzer-max-filters");
690      builder.setOption(PropertyOption.ADVANCED);
691      builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "index-filter-analyzer-max-filters"));
692      DefaultBehaviorProvider<Integer> provider = new DefinedDefaultBehaviorProvider<Integer>("25");
693      builder.setDefaultBehaviorProvider(provider);
694      builder.setLowerLimit(1);
695      PD_INDEX_FILTER_ANALYZER_MAX_FILTERS = builder.getInstance();
696      INSTANCE.registerPropertyDefinition(PD_INDEX_FILTER_ANALYZER_MAX_FILTERS);
697  }
698
699
700
701  // Build the "java-class" property definition.
702  static {
703      ClassPropertyDefinition.Builder builder = ClassPropertyDefinition.createBuilder(INSTANCE, "java-class");
704      builder.setOption(PropertyOption.MANDATORY);
705      builder.setOption(PropertyOption.ADVANCED);
706      builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.COMPONENT_RESTART, INSTANCE, "java-class"));
707      DefaultBehaviorProvider<String> provider = new DefinedDefaultBehaviorProvider<String>("org.opends.server.backends.jeb.BackendImpl");
708      builder.setDefaultBehaviorProvider(provider);
709      builder.addInstanceOf("org.opends.server.api.Backend");
710      PD_JAVA_CLASS = builder.getInstance();
711      INSTANCE.registerPropertyDefinition(PD_JAVA_CLASS);
712  }
713
714
715
716  // Build the "je-property" property definition.
717  static {
718      StringPropertyDefinition.Builder builder = StringPropertyDefinition.createBuilder(INSTANCE, "je-property");
719      builder.setOption(PropertyOption.MULTI_VALUED);
720      builder.setOption(PropertyOption.ADVANCED);
721      builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "je-property"));
722      builder.setDefaultBehaviorProvider(new UndefinedDefaultBehaviorProvider<String>());
723      PD_JE_PROPERTY = builder.getInstance();
724      INSTANCE.registerPropertyDefinition(PD_JE_PROPERTY);
725  }
726
727
728
729  // Build the "preload-time-limit" property definition.
730  static {
731      DurationPropertyDefinition.Builder builder = DurationPropertyDefinition.createBuilder(INSTANCE, "preload-time-limit");
732      builder.setOption(PropertyOption.ADVANCED);
733      builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "preload-time-limit"));
734      DefaultBehaviorProvider<Long> provider = new DefinedDefaultBehaviorProvider<Long>("0s");
735      builder.setDefaultBehaviorProvider(provider);
736      builder.setBaseUnit("ms");
737      builder.setUpperLimit("2147483647");
738      builder.setLowerLimit("0");
739      PD_PRELOAD_TIME_LIMIT = builder.getInstance();
740      INSTANCE.registerPropertyDefinition(PD_PRELOAD_TIME_LIMIT);
741  }
742
743
744
745  // Build the "subordinate-indexes-enabled" property definition.
746  static {
747      BooleanPropertyDefinition.Builder builder = BooleanPropertyDefinition.createBuilder(INSTANCE, "subordinate-indexes-enabled");
748      builder.setOption(PropertyOption.ADVANCED);
749      builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "subordinate-indexes-enabled"));
750      DefaultBehaviorProvider<Boolean> provider = new DefinedDefaultBehaviorProvider<Boolean>("true");
751      builder.setDefaultBehaviorProvider(provider);
752      PD_SUBORDINATE_INDEXES_ENABLED = builder.getInstance();
753      INSTANCE.registerPropertyDefinition(PD_SUBORDINATE_INDEXES_ENABLED);
754  }
755
756
757
758  // Build the "writability-mode" property definition.
759  static {
760      EnumPropertyDefinition.Builder<WritabilityMode> builder = EnumPropertyDefinition.createBuilder(INSTANCE, "writability-mode");
761      builder.setOption(PropertyOption.MANDATORY);
762      builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "writability-mode"));
763      DefaultBehaviorProvider<WritabilityMode> provider = new DefinedDefaultBehaviorProvider<WritabilityMode>("enabled");
764      builder.setDefaultBehaviorProvider(provider);
765      builder.setEnumClass(WritabilityMode.class);
766      PD_WRITABILITY_MODE = builder.getInstance();
767      INSTANCE.registerPropertyDefinition(PD_WRITABILITY_MODE);
768  }
769
770
771
772  // Build the "local-db-indexes" relation definition.
773  static {
774    InstantiableRelationDefinition.Builder<LocalDBIndexCfgClient, LocalDBIndexCfg> builder =
775      new InstantiableRelationDefinition.Builder<LocalDBIndexCfgClient, LocalDBIndexCfg>(INSTANCE, "local-db-index", "local-db-indexes", LocalDBIndexCfgDefn.getInstance());
776    builder.setNamingProperty(LocalDBIndexCfgDefn.getInstance().getAttributePropertyDefinition());
777    {
778      DefaultManagedObject.Builder<LocalDBIndexCfgClient, LocalDBIndexCfg> dmoBuilder = new DefaultManagedObject.Builder<LocalDBIndexCfgClient, LocalDBIndexCfg>(LocalDBIndexCfgDefn.getInstance());
779      dmoBuilder.setPropertyValues("index-type", "presence");
780      dmoBuilder.setPropertyValues("attribute", "aci");
781      builder.setDefaultManagedObject("aci", dmoBuilder.getInstance());
782    }
783    {
784      DefaultManagedObject.Builder<LocalDBIndexCfgClient, LocalDBIndexCfg> dmoBuilder = new DefaultManagedObject.Builder<LocalDBIndexCfgClient, LocalDBIndexCfg>(LocalDBIndexCfgDefn.getInstance());
785      dmoBuilder.setPropertyValues("index-type", "equality");
786      dmoBuilder.setPropertyValues("attribute", "entryUUID");
787      builder.setDefaultManagedObject("entryUUID", dmoBuilder.getInstance());
788    }
789    {
790      DefaultManagedObject.Builder<LocalDBIndexCfgClient, LocalDBIndexCfg> dmoBuilder = new DefaultManagedObject.Builder<LocalDBIndexCfgClient, LocalDBIndexCfg>(LocalDBIndexCfgDefn.getInstance());
791      dmoBuilder.setPropertyValues("index-type", "equality");
792      dmoBuilder.setPropertyValues("attribute", "objectClass");
793      builder.setDefaultManagedObject("objectClass", dmoBuilder.getInstance());
794    }
795    {
796      DefaultManagedObject.Builder<LocalDBIndexCfgClient, LocalDBIndexCfg> dmoBuilder = new DefaultManagedObject.Builder<LocalDBIndexCfgClient, LocalDBIndexCfg>(LocalDBIndexCfgDefn.getInstance());
797      dmoBuilder.setPropertyValues("index-type", "ordering");
798      dmoBuilder.setPropertyValues("attribute", "ds-sync-hist");
799      builder.setDefaultManagedObject("ds-sync-hist", dmoBuilder.getInstance());
800    }
801    {
802      DefaultManagedObject.Builder<LocalDBIndexCfgClient, LocalDBIndexCfg> dmoBuilder = new DefaultManagedObject.Builder<LocalDBIndexCfgClient, LocalDBIndexCfg>(LocalDBIndexCfgDefn.getInstance());
803      dmoBuilder.setPropertyValues("index-type", "equality");
804      dmoBuilder.setPropertyValues("attribute", "ds-sync-conflict");
805      builder.setDefaultManagedObject("ds-sync-conflict", dmoBuilder.getInstance());
806    }
807    RD_LOCAL_DB_INDEXES = builder.getInstance();
808    INSTANCE.registerRelationDefinition(RD_LOCAL_DB_INDEXES);
809  }
810
811
812
813  // Build the "local-db-vlv-indexes" relation definition.
814  static {
815    InstantiableRelationDefinition.Builder<LocalDBVLVIndexCfgClient, LocalDBVLVIndexCfg> builder =
816      new InstantiableRelationDefinition.Builder<LocalDBVLVIndexCfgClient, LocalDBVLVIndexCfg>(INSTANCE, "local-db-vlv-index", "local-db-vlv-indexes", LocalDBVLVIndexCfgDefn.getInstance());
817    builder.setNamingProperty(LocalDBVLVIndexCfgDefn.getInstance().getNamePropertyDefinition());
818    RD_LOCAL_DB_VLV_INDEXES = builder.getInstance();
819    INSTANCE.registerRelationDefinition(RD_LOCAL_DB_VLV_INDEXES);
820  }
821
822
823
824  // Register the tags associated with this managed object definition.
825  static {
826    INSTANCE.registerTag(Tag.valueOf("database"));
827  }
828
829
830
831  // Register the constraints associated with this managed object definition.
832  static {
833    INSTANCE.registerConstraint(new GenericConstraint(INSTANCE, 1, Conditions.implies(Conditions.contains("enabled", "true"), Conditions.not(Conditions.and(Conditions.contains("db-txn-no-sync", "true"), Conditions.contains("db-txn-write-no-sync", "true"))))));
834  }
835
836
837
838  /**
839   * Get the Local DB Backend configuration definition singleton.
840   *
841   * @return Returns the Local DB Backend configuration definition
842   *         singleton.
843   */
844  public static LocalDBBackendCfgDefn getInstance() {
845    return INSTANCE;
846  }
847
848
849
850  /**
851   * Private constructor.
852   */
853  private LocalDBBackendCfgDefn() {
854    super("local-db-backend", BackendCfgDefn.getInstance());
855  }
856
857
858
859  /**
860   * {@inheritDoc}
861   */
862  public LocalDBBackendCfgClient createClientConfiguration(
863      ManagedObject<? extends LocalDBBackendCfgClient> impl) {
864    return new LocalDBBackendCfgClientImpl(impl);
865  }
866
867
868
869  /**
870   * {@inheritDoc}
871   */
872  public LocalDBBackendCfg createServerConfiguration(
873      ServerManagedObject<? extends LocalDBBackendCfg> impl) {
874    return new LocalDBBackendCfgServerImpl(impl);
875  }
876
877
878
879  /**
880   * {@inheritDoc}
881   */
882  public Class<LocalDBBackendCfg> getServerConfigurationClass() {
883    return LocalDBBackendCfg.class;
884  }
885
886
887
888  /**
889   * Get the "backend-id" property definition.
890   * <p>
891   * Specifies a name to identify the associated backend.
892   * <p>
893   * The name must be unique among all backends in the server. The
894   * backend ID may not be altered after the backend is created in the
895   * server.
896   *
897   * @return Returns the "backend-id" property definition.
898   */
899  public StringPropertyDefinition getBackendIdPropertyDefinition() {
900    return BackendCfgDefn.getInstance().getBackendIdPropertyDefinition();
901  }
902
903
904
905  /**
906   * Get the "base-dn" property definition.
907   * <p>
908   * Specifies the base DN(s) for the data that the backend handles.
909   * <p>
910   * A single backend may be responsible for one or more base DNs.
911   * Note that no two backends may have the same base DN although one
912   * backend may have a base DN that is below a base DN provided by
913   * another backend (similar to the use of sub-suffixes in the Sun
914   * Java System Directory Server). If any of the base DNs is
915   * subordinate to a base DN for another backend, then all base DNs
916   * for that backend must be subordinate to that same base DN.
917   *
918   * @return Returns the "base-dn" property definition.
919   */
920  public DNPropertyDefinition getBaseDNPropertyDefinition() {
921    return BackendCfgDefn.getInstance().getBaseDNPropertyDefinition();
922  }
923
924
925
926  /**
927   * Get the "compact-encoding" property definition.
928   * <p>
929   * Indicates whether the backend should use a compact form when
930   * encoding entries by compressing the attribute descriptions and
931   * object class sets.
932   * <p>
933   * Note that this property applies only to the entries themselves
934   * and does not impact the index data.
935   *
936   * @return Returns the "compact-encoding" property definition.
937   */
938  public BooleanPropertyDefinition getCompactEncodingPropertyDefinition() {
939    return PD_COMPACT_ENCODING;
940  }
941
942
943
944  /**
945   * Get the "db-cache-percent" property definition.
946   * <p>
947   * Specifies the percentage of JVM memory to allocate to the
948   * database cache.
949   * <p>
950   * Specifies the percentage of memory available to the JVM that
951   * should be used for caching database contents. Note that this is
952   * only used if the value of the db-cache-size property is set to "0
953   * MB". Otherwise, the value of that property is used instead to
954   * control the cache size configuration.
955   *
956   * @return Returns the "db-cache-percent" property definition.
957   */
958  public IntegerPropertyDefinition getDBCachePercentPropertyDefinition() {
959    return PD_DB_CACHE_PERCENT;
960  }
961
962
963
964  /**
965   * Get the "db-cache-size" property definition.
966   * <p>
967   * The amount of JVM memory to allocate to the database cache.
968   * <p>
969   * Specifies the amount of memory that should be used for caching
970   * database contents. A value of "0 MB" indicates that the
971   * db-cache-percent property should be used instead to specify the
972   * cache size.
973   *
974   * @return Returns the "db-cache-size" property definition.
975   */
976  public SizePropertyDefinition getDBCacheSizePropertyDefinition() {
977    return PD_DB_CACHE_SIZE;
978  }
979
980
981
982  /**
983   * Get the "db-checkpointer-bytes-interval" property definition.
984   * <p>
985   * Specifies the maximum number of bytes that may be written to the
986   * database before it is forced to perform a checkpoint.
987   * <p>
988   * This can be used to bound the recovery time that may be required
989   * if the database environment is opened without having been properly
990   * closed. If this property is set to a non-zero value, the
991   * checkpointer wakeup interval is not used. To use time-based
992   * checkpointing, set this property to zero.
993   *
994   * @return Returns the "db-checkpointer-bytes-interval" property definition.
995   */
996  public SizePropertyDefinition getDBCheckpointerBytesIntervalPropertyDefinition() {
997    return PD_DB_CHECKPOINTER_BYTES_INTERVAL;
998  }
999
1000
1001
1002  /**
1003   * Get the "db-checkpointer-wakeup-interval" property definition.
1004   * <p>
1005   * Specifies the maximum length of time that may pass between
1006   * checkpoints.
1007   * <p>
1008   * Note that this is only used if the value of the checkpointer
1009   * bytes interval is zero.
1010   *
1011   * @return Returns the "db-checkpointer-wakeup-interval" property definition.
1012   */
1013  public DurationPropertyDefinition getDBCheckpointerWakeupIntervalPropertyDefinition() {
1014    return PD_DB_CHECKPOINTER_WAKEUP_INTERVAL;
1015  }
1016
1017
1018
1019  /**
1020   * Get the "db-cleaner-min-utilization" property definition.
1021   * <p>
1022   * Specifies the minimum percentage of "live" data that the database
1023   * cleaner attempts to keep in database log files.
1024   * <p>
1025   * If the amount of live data in any database log file drops below
1026   * this percentage, then the cleaner moves the remaining live data in
1027   * that file to the end of the database and deletes the original file
1028   * in order to keep the database relatively compact.
1029   *
1030   * @return Returns the "db-cleaner-min-utilization" property definition.
1031   */
1032  public IntegerPropertyDefinition getDBCleanerMinUtilizationPropertyDefinition() {
1033    return PD_DB_CLEANER_MIN_UTILIZATION;
1034  }
1035
1036
1037
1038  /**
1039   * Get the "db-directory" property definition.
1040   * <p>
1041   * Specifies the path to the filesystem directory that is used to
1042   * hold the Berkeley DB Java Edition database files containing the
1043   * data for this backend.
1044   * <p>
1045   * The path may be either an absolute path or a path relative to the
1046   * directory containing the base of the OpenDJ directory server
1047   * installation. The path may be any valid directory path in which
1048   * the server has appropriate permissions to read and write files and
1049   * has sufficient space to hold the database contents.
1050   *
1051   * @return Returns the "db-directory" property definition.
1052   */
1053  public StringPropertyDefinition getDBDirectoryPropertyDefinition() {
1054    return PD_DB_DIRECTORY;
1055  }
1056
1057
1058
1059  /**
1060   * Get the "db-directory-permissions" property definition.
1061   * <p>
1062   * Specifies the permissions that should be applied to the directory
1063   * containing the server database files.
1064   * <p>
1065   * They should be expressed as three-digit octal values, which is
1066   * the traditional representation for UNIX file permissions. The
1067   * three digits represent the permissions that are available for the
1068   * directory's owner, group members, and other users (in that order),
1069   * and each digit is the octal representation of the read, write, and
1070   * execute bits. Note that this only impacts permissions on the
1071   * database directory and not on the files written into that
1072   * directory. On UNIX systems, the user's umask controls permissions
1073   * given to the database files.
1074   *
1075   * @return Returns the "db-directory-permissions" property definition.
1076   */
1077  public StringPropertyDefinition getDBDirectoryPermissionsPropertyDefinition() {
1078    return PD_DB_DIRECTORY_PERMISSIONS;
1079  }
1080
1081
1082
1083  /**
1084   * Get the "db-evictor-core-threads" property definition.
1085   * <p>
1086   * Specifies the core number of threads in the eviction thread pool.
1087   * <p>
1088   * Specifies the core number of threads in the eviction thread pool.
1089   * These threads help keep memory usage within cache bounds,
1090   * offloading work from application threads. db-evictor-core-threads,
1091   * db-evictor-max-threads and db-evictor-keep-alive are used to
1092   * configure the core, max and keepalive attributes for the eviction
1093   * thread pool.
1094   *
1095   * @return Returns the "db-evictor-core-threads" property definition.
1096   */
1097  public IntegerPropertyDefinition getDBEvictorCoreThreadsPropertyDefinition() {
1098    return PD_DB_EVICTOR_CORE_THREADS;
1099  }
1100
1101
1102
1103  /**
1104   * Get the "db-evictor-keep-alive" property definition.
1105   * <p>
1106   * The duration that excess threads in the eviction thread pool will
1107   * stay idle. After this period, idle threads will terminate.
1108   * <p>
1109   * The duration that excess threads in the eviction thread pool will
1110   * stay idle. After this period, idle threads will terminate.
1111   * db-evictor-core-threads, db-evictor-max-threads and
1112   * db-evictor-keep-alive are used to configure the core, max and
1113   * keepalive attributes for the eviction thread pool.
1114   *
1115   * @return Returns the "db-evictor-keep-alive" property definition.
1116   */
1117  public DurationPropertyDefinition getDBEvictorKeepAlivePropertyDefinition() {
1118    return PD_DB_EVICTOR_KEEP_ALIVE;
1119  }
1120
1121
1122
1123  /**
1124   * Get the "db-evictor-lru-only" property definition.
1125   * <p>
1126   * Indicates whether the database should evict existing data from
1127   * the cache based on an LRU policy (where the least recently used
1128   * information will be evicted first).
1129   * <p>
1130   * If set to "false", then the eviction keeps internal nodes of the
1131   * underlying Btree in the cache over leaf nodes, even if the leaf
1132   * nodes have been accessed more recently. This may be a better
1133   * configuration for databases in which only a very small portion of
1134   * the data is cached.
1135   *
1136   * @return Returns the "db-evictor-lru-only" property definition.
1137   */
1138  public BooleanPropertyDefinition getDBEvictorLruOnlyPropertyDefinition() {
1139    return PD_DB_EVICTOR_LRU_ONLY;
1140  }
1141
1142
1143
1144  /**
1145   * Get the "db-evictor-max-threads" property definition.
1146   * <p>
1147   * Specifies the maximum number of threads in the eviction thread
1148   * pool.
1149   * <p>
1150   * Specifies the maximum number of threads in the eviction thread
1151   * pool. These threads help keep memory usage within cache bounds,
1152   * offloading work from application threads. db-evictor-core-threads,
1153   * db-evictor-max-threads and db-evictor-keep-alive are used to
1154   * configure the core, max and keepalive attributes for the eviction
1155   * thread pool.
1156   *
1157   * @return Returns the "db-evictor-max-threads" property definition.
1158   */
1159  public IntegerPropertyDefinition getDBEvictorMaxThreadsPropertyDefinition() {
1160    return PD_DB_EVICTOR_MAX_THREADS;
1161  }
1162
1163
1164
1165  /**
1166   * Get the "db-evictor-nodes-per-scan" property definition.
1167   * <p>
1168   * Specifies the number of Btree nodes that should be evicted from
1169   * the cache in a single pass if it is determined that it is
1170   * necessary to free existing data in order to make room for new
1171   * information.
1172   * <p>
1173   * Changes to this property do not take effect until the backend is
1174   * restarted. It is recommended that you also change this property
1175   * when you set db-evictor-lru-only to false. This setting controls
1176   * the number of Btree nodes that are considered, or sampled, each
1177   * time a node is evicted. A setting of 10 often produces good
1178   * results, but this may vary from application to application. The
1179   * larger the nodes per scan, the more accurate the algorithm.
1180   * However, don't set it too high. When considering larger numbers of
1181   * nodes for each eviction, the evictor may delay the completion of a
1182   * given database operation, which impacts the response time of the
1183   * application thread. In JE 4.1 and later, setting this value too
1184   * high in an application that is largely CPU bound can reduce the
1185   * effectiveness of cache eviction. It's best to start with the
1186   * default value, and increase it gradually to see if it is
1187   * beneficial for your application.
1188   *
1189   * @return Returns the "db-evictor-nodes-per-scan" property definition.
1190   */
1191  public IntegerPropertyDefinition getDBEvictorNodesPerScanPropertyDefinition() {
1192    return PD_DB_EVICTOR_NODES_PER_SCAN;
1193  }
1194
1195
1196
1197  /**
1198   * Get the "db-log-filecache-size" property definition.
1199   * <p>
1200   * Specifies the size of the file handle cache.
1201   * <p>
1202   * The file handle cache is used to keep as much opened log files as
1203   * possible. When the cache is smaller than the number of logs, the
1204   * database needs to close some handles and open log files it needs,
1205   * resulting in less optimal performances. Ideally, the size of the
1206   * cache should be higher than the number of files contained in the
1207   * database. Make sure the OS number of open files per process is
1208   * also tuned appropriately.
1209   *
1210   * @return Returns the "db-log-filecache-size" property definition.
1211   */
1212  public IntegerPropertyDefinition getDBLogFilecacheSizePropertyDefinition() {
1213    return PD_DB_LOG_FILECACHE_SIZE;
1214  }
1215
1216
1217
1218  /**
1219   * Get the "db-log-file-max" property definition.
1220   * <p>
1221   * Specifies the maximum size for a database log file.
1222   *
1223   * @return Returns the "db-log-file-max" property definition.
1224   */
1225  public SizePropertyDefinition getDBLogFileMaxPropertyDefinition() {
1226    return PD_DB_LOG_FILE_MAX;
1227  }
1228
1229
1230
1231  /**
1232   * Get the "db-logging-file-handler-on" property definition.
1233   * <p>
1234   * Indicates whether the database should maintain a je.info file in
1235   * the same directory as the database log directory.
1236   * <p>
1237   * This file contains information about the internal processing
1238   * performed by the underlying database.
1239   *
1240   * @return Returns the "db-logging-file-handler-on" property definition.
1241   */
1242  public BooleanPropertyDefinition getDBLoggingFileHandlerOnPropertyDefinition() {
1243    return PD_DB_LOGGING_FILE_HANDLER_ON;
1244  }
1245
1246
1247
1248  /**
1249   * Get the "db-logging-level" property definition.
1250   * <p>
1251   * Specifies the log level that should be used by the database when
1252   * it is writing information into the je.info file.
1253   * <p>
1254   * The database trace logging level is (in increasing order of
1255   * verbosity) chosen from: OFF, SEVERE, WARNING, INFO, CONFIG, FINE,
1256   * FINER, FINEST, ALL.
1257   *
1258   * @return Returns the "db-logging-level" property definition.
1259   */
1260  public StringPropertyDefinition getDBLoggingLevelPropertyDefinition() {
1261    return PD_DB_LOGGING_LEVEL;
1262  }
1263
1264
1265
1266  /**
1267   * Get the "db-num-cleaner-threads" property definition.
1268   * <p>
1269   * Specifies the number of threads that the backend should maintain
1270   * to keep the database log files at or near the desired utilization.
1271   * <p>
1272   * In environments with high write throughput, multiple cleaner
1273   * threads may be required to maintain the desired utilization.
1274   *
1275   * @return Returns the "db-num-cleaner-threads" property definition.
1276   */
1277  public IntegerPropertyDefinition getDBNumCleanerThreadsPropertyDefinition() {
1278    return PD_DB_NUM_CLEANER_THREADS;
1279  }
1280
1281
1282
1283  /**
1284   * Get the "db-num-lock-tables" property definition.
1285   * <p>
1286   * Specifies the number of lock tables that are used by the
1287   * underlying database.
1288   * <p>
1289   * This can be particularly important to help improve scalability by
1290   * avoiding contention on systems with large numbers of CPUs. The
1291   * value of this configuration property should be set to a prime
1292   * number that is less than or equal to the number of worker threads
1293   * configured for use in the server.
1294   *
1295   * @return Returns the "db-num-lock-tables" property definition.
1296   */
1297  public IntegerPropertyDefinition getDBNumLockTablesPropertyDefinition() {
1298    return PD_DB_NUM_LOCK_TABLES;
1299  }
1300
1301
1302
1303  /**
1304   * Get the "db-run-cleaner" property definition.
1305   * <p>
1306   * Indicates whether the database cleaner threads should be enabled.
1307   * <p>
1308   * The cleaner threads are used to periodically compact the database
1309   * by identifying database files with a low (that is, less than the
1310   * amount specified by the db-cleaner-min-utilization property)
1311   * percentage of live data, moving the remaining live data to the end
1312   * of the log and deleting that file.
1313   *
1314   * @return Returns the "db-run-cleaner" property definition.
1315   */
1316  public BooleanPropertyDefinition getDBRunCleanerPropertyDefinition() {
1317    return PD_DB_RUN_CLEANER;
1318  }
1319
1320
1321
1322  /**
1323   * Get the "db-txn-no-sync" property definition.
1324   * <p>
1325   * Indicates whether database writes should be primarily written to
1326   * an internal buffer but not immediately written to disk.
1327   * <p>
1328   * Setting the value of this configuration attribute to "true" may
1329   * improve write performance but could cause the most recent changes
1330   * to be lost if the OpenDJ directory server or the underlying JVM
1331   * exits abnormally, or if an OS or hardware failure occurs (a
1332   * behavior similar to running with transaction durability disabled
1333   * in the Sun Java System Directory Server).
1334   *
1335   * @return Returns the "db-txn-no-sync" property definition.
1336   */
1337  public BooleanPropertyDefinition getDBTxnNoSyncPropertyDefinition() {
1338    return PD_DB_TXN_NO_SYNC;
1339  }
1340
1341
1342
1343  /**
1344   * Get the "db-txn-write-no-sync" property definition.
1345   * <p>
1346   * Indicates whether the database should synchronously flush data as
1347   * it is written to disk.
1348   * <p>
1349   * If this value is set to "false", then all data written to disk is
1350   * synchronously flushed to persistent storage and thereby providing
1351   * full durability. If it is set to "true", then data may be cached
1352   * for a period of time by the underlying operating system before
1353   * actually being written to disk. This may improve performance, but
1354   * could cause the most recent changes to be lost in the event of an
1355   * underlying OS or hardware failure (but not in the case that the
1356   * OpenDJ directory server or the JVM exits abnormally).
1357   *
1358   * @return Returns the "db-txn-write-no-sync" property definition.
1359   */
1360  public BooleanPropertyDefinition getDBTxnWriteNoSyncPropertyDefinition() {
1361    return PD_DB_TXN_WRITE_NO_SYNC;
1362  }
1363
1364
1365
1366  /**
1367   * Get the "disk-full-threshold" property definition.
1368   * <p>
1369   * Full disk threshold to limit database updates
1370   * <p>
1371   * When the available free space on the disk used by this database
1372   * instance falls below the value specified, no updates are permitted
1373   * and the server returns an UNWILLING_TO_PERFORM error. Updates are
1374   * allowed again as soon as free space rises above the threshold.
1375   *
1376   * @return Returns the "disk-full-threshold" property definition.
1377   */
1378  public SizePropertyDefinition getDiskFullThresholdPropertyDefinition() {
1379    return PD_DISK_FULL_THRESHOLD;
1380  }
1381
1382
1383
1384  /**
1385   * Get the "disk-low-threshold" property definition.
1386   * <p>
1387   * Low disk threshold to limit database updates
1388   * <p>
1389   * Specifies the "low" free space on the disk. When the available
1390   * free space on the disk used by this database instance falls below
1391   * the value specified, protocol updates on this database are
1392   * permitted only by a user with the BYPASS_LOCKDOWN privilege.
1393   *
1394   * @return Returns the "disk-low-threshold" property definition.
1395   */
1396  public SizePropertyDefinition getDiskLowThresholdPropertyDefinition() {
1397    return PD_DISK_LOW_THRESHOLD;
1398  }
1399
1400
1401
1402  /**
1403   * Get the "enabled" property definition.
1404   * <p>
1405   * Indicates whether the backend is enabled in the server.
1406   * <p>
1407   * If a backend is not enabled, then its contents are not accessible
1408   * when processing operations.
1409   *
1410   * @return Returns the "enabled" property definition.
1411   */
1412  public BooleanPropertyDefinition getEnabledPropertyDefinition() {
1413    return BackendCfgDefn.getInstance().getEnabledPropertyDefinition();
1414  }
1415
1416
1417
1418  /**
1419   * Get the "entries-compressed" property definition.
1420   * <p>
1421   * Indicates whether the backend should attempt to compress entries
1422   * before storing them in the database.
1423   * <p>
1424   * Note that this property applies only to the entries themselves
1425   * and does not impact the index data. Further, the effectiveness of
1426   * the compression is based on the type of data contained in the
1427   * entry.
1428   *
1429   * @return Returns the "entries-compressed" property definition.
1430   */
1431  public BooleanPropertyDefinition getEntriesCompressedPropertyDefinition() {
1432    return PD_ENTRIES_COMPRESSED;
1433  }
1434
1435
1436
1437  /**
1438   * Get the "import-queue-size" property definition.
1439   * <p>
1440   * This parameter has been deprecated in OpenDS 2.1 and will be
1441   * removed in OpenDJ 3.0. It is only being kept for migration ease
1442   * and is ignored in OpenDS versions after 2.0.
1443   *
1444   * @return Returns the "import-queue-size" property definition.
1445   */
1446  public IntegerPropertyDefinition getImportQueueSizePropertyDefinition() {
1447    return PD_IMPORT_QUEUE_SIZE;
1448  }
1449
1450
1451
1452  /**
1453   * Get the "import-thread-count" property definition.
1454   * <p>
1455   * This parameter has been deprecated in OpenDS 2.1 and will be
1456   * removed in OpenDJ 3.0. It is only being kept for migration ease
1457   * and is ignored in OpenDS versions after 2.0.
1458   * <p>
1459   * This parameter has been deprecated in OpenDS 2.1 and will be
1460   * removed in OpenDJ 3.0. It is only being kept for migration ease
1461   * and is ignored in OpenDS versions after 2.0.
1462   *
1463   * @return Returns the "import-thread-count" property definition.
1464   */
1465  public IntegerPropertyDefinition getImportThreadCountPropertyDefinition() {
1466    return PD_IMPORT_THREAD_COUNT;
1467  }
1468
1469
1470
1471  /**
1472   * Get the "index-entry-limit" property definition.
1473   * <p>
1474   * Specifies the maximum number of entries that is allowed to match
1475   * a given index key before that particular index key is no longer
1476   * maintained.
1477   * <p>
1478   * This property is analogous to the ALL IDs threshold in the Sun
1479   * Java System Directory Server. Note that this is the default limit
1480   * for the backend, and it may be overridden on a per-attribute
1481   * basis.A value of 0 means there is no limit.
1482   *
1483   * @return Returns the "index-entry-limit" property definition.
1484   */
1485  public IntegerPropertyDefinition getIndexEntryLimitPropertyDefinition() {
1486    return PD_INDEX_ENTRY_LIMIT;
1487  }
1488
1489
1490
1491  /**
1492   * Get the "index-filter-analyzer-enabled" property definition.
1493   * <p>
1494   * Indicates whether to gather statistical information about the
1495   * search filters processed by the directory server while evaluating
1496   * the usage of indexes.
1497   * <p>
1498   * Analyzing indexes requires gathering search filter usage patterns
1499   * from user requests, especially for values as specified in the
1500   * filters and subsequently looking the status of those values into
1501   * the index files. When a search requests is processed, internal or
1502   * user generated, a first phase uses indexes to find potential
1503   * entries to be returned. Depending on the search filter, if the
1504   * index of one of the specified attributes matches too many entries
1505   * (exceeds the index entry limit), the search becomes non-indexed.
1506   * In any case, all entries thus gathered (or the entire DIT) are
1507   * matched against the filter for actually returning the search
1508   * result.
1509   *
1510   * @return Returns the "index-filter-analyzer-enabled" property definition.
1511   */
1512  public BooleanPropertyDefinition getIndexFilterAnalyzerEnabledPropertyDefinition() {
1513    return PD_INDEX_FILTER_ANALYZER_ENABLED;
1514  }
1515
1516
1517
1518  /**
1519   * Get the "index-filter-analyzer-max-filters" property definition.
1520   * <p>
1521   * The maximum number of search filter statistics to keep.
1522   * <p>
1523   * When the maximum number of search filter is reached, the least
1524   * used one will be deleted.
1525   *
1526   * @return Returns the "index-filter-analyzer-max-filters" property definition.
1527   */
1528  public IntegerPropertyDefinition getIndexFilterAnalyzerMaxFiltersPropertyDefinition() {
1529    return PD_INDEX_FILTER_ANALYZER_MAX_FILTERS;
1530  }
1531
1532
1533
1534  /**
1535   * Get the "java-class" property definition.
1536   * <p>
1537   * Specifies the fully-qualified name of the Java class that
1538   * provides the backend implementation.
1539   *
1540   * @return Returns the "java-class" property definition.
1541   */
1542  public ClassPropertyDefinition getJavaClassPropertyDefinition() {
1543    return PD_JAVA_CLASS;
1544  }
1545
1546
1547
1548  /**
1549   * Get the "je-property" property definition.
1550   * <p>
1551   * Specifies the database and environment properties for the
1552   * Berkeley DB Java Edition database serving the data for this
1553   * backend.
1554   * <p>
1555   * Any Berkeley DB Java Edition property can be specified using the
1556   * following form: property-name=property-value. Refer to OpenDJ
1557   * documentation for further information on related properties, their
1558   * implications, and range values. The definitive identification of
1559   * all the property parameters is available in the example.properties
1560   * file of Berkeley DB Java Edition distribution.
1561   *
1562   * @return Returns the "je-property" property definition.
1563   */
1564  public StringPropertyDefinition getJEPropertyPropertyDefinition() {
1565    return PD_JE_PROPERTY;
1566  }
1567
1568
1569
1570  /**
1571   * Get the "preload-time-limit" property definition.
1572   * <p>
1573   * Specifies the length of time that the backend is allowed to spend
1574   * "pre-loading" data when it is initialized.
1575   * <p>
1576   * The pre-load process is used to pre-populate the database cache,
1577   * so that it can be more quickly available when the server is
1578   * processing requests. A duration of zero means there is no
1579   * pre-load.
1580   *
1581   * @return Returns the "preload-time-limit" property definition.
1582   */
1583  public DurationPropertyDefinition getPreloadTimeLimitPropertyDefinition() {
1584    return PD_PRELOAD_TIME_LIMIT;
1585  }
1586
1587
1588
1589  /**
1590   * Get the "subordinate-indexes-enabled" property definition.
1591   * <p>
1592   * Indicates whether id2children and id2subtree indexes should be
1593   * used for this backend. These indexes are used for constraining
1594   * filtered searches to the search request's scope as well as for
1595   * generating values for the hasSubordinates and numSubordinates
1596   * virtual attributes.
1597   * <p>
1598   * Subordinate indexing is enabled by default and should only be
1599   * disabled for specialized use cases. A typical use case is where
1600   * the backend is to be subjected to heavy add/delete load beneath
1601   * the same parent entry such as when used as a session database.
1602   * Disabling the subordinate indexes means that the numSubordinates
1603   * and hasSubordinates virtual attributes will not be supported.
1604   *
1605   * @return Returns the "subordinate-indexes-enabled" property definition.
1606   */
1607  public BooleanPropertyDefinition getSubordinateIndexesEnabledPropertyDefinition() {
1608    return PD_SUBORDINATE_INDEXES_ENABLED;
1609  }
1610
1611
1612
1613  /**
1614   * Get the "writability-mode" property definition.
1615   * <p>
1616   * Specifies the behavior that the backend should use when
1617   * processing write operations.
1618   *
1619   * @return Returns the "writability-mode" property definition.
1620   */
1621  public EnumPropertyDefinition<WritabilityMode> getWritabilityModePropertyDefinition() {
1622    return PD_WRITABILITY_MODE;
1623  }
1624
1625
1626
1627  /**
1628   * Get the "local-db-indexes" relation definition.
1629   *
1630   * @return Returns the "local-db-indexes" relation definition.
1631   */
1632  public InstantiableRelationDefinition<LocalDBIndexCfgClient,LocalDBIndexCfg> getLocalDBIndexesRelationDefinition() {
1633    return RD_LOCAL_DB_INDEXES;
1634  }
1635
1636
1637
1638  /**
1639   * Get the "local-db-vlv-indexes" relation definition.
1640   *
1641   * @return Returns the "local-db-vlv-indexes" relation definition.
1642   */
1643  public InstantiableRelationDefinition<LocalDBVLVIndexCfgClient,LocalDBVLVIndexCfg> getLocalDBVLVIndexesRelationDefinition() {
1644    return RD_LOCAL_DB_VLV_INDEXES;
1645  }
1646
1647
1648
1649  /**
1650   * Managed object client implementation.
1651   */
1652  private static class LocalDBBackendCfgClientImpl implements
1653    LocalDBBackendCfgClient {
1654
1655    // Private implementation.
1656    private ManagedObject<? extends LocalDBBackendCfgClient> impl;
1657
1658
1659
1660    // Private constructor.
1661    private LocalDBBackendCfgClientImpl(
1662        ManagedObject<? extends LocalDBBackendCfgClient> impl) {
1663      this.impl = impl;
1664    }
1665
1666
1667
1668    /**
1669     * {@inheritDoc}
1670     */
1671    public String getBackendId() {
1672      return impl.getPropertyValue(INSTANCE.getBackendIdPropertyDefinition());
1673    }
1674
1675
1676
1677    /**
1678     * {@inheritDoc}
1679     */
1680    public void setBackendId(String value) throws PropertyException {
1681      impl.setPropertyValue(INSTANCE.getBackendIdPropertyDefinition(), value);
1682    }
1683
1684
1685
1686    /**
1687     * {@inheritDoc}
1688     */
1689    public SortedSet<DN> getBaseDN() {
1690      return impl.getPropertyValues(INSTANCE.getBaseDNPropertyDefinition());
1691    }
1692
1693
1694
1695    /**
1696     * {@inheritDoc}
1697     */
1698    public void setBaseDN(Collection<DN> values) {
1699      impl.setPropertyValues(INSTANCE.getBaseDNPropertyDefinition(), values);
1700    }
1701
1702
1703
1704    /**
1705     * {@inheritDoc}
1706     */
1707    public boolean isCompactEncoding() {
1708      return impl.getPropertyValue(INSTANCE.getCompactEncodingPropertyDefinition());
1709    }
1710
1711
1712
1713    /**
1714     * {@inheritDoc}
1715     */
1716    public void setCompactEncoding(Boolean value) {
1717      impl.setPropertyValue(INSTANCE.getCompactEncodingPropertyDefinition(), value);
1718    }
1719
1720
1721
1722    /**
1723     * {@inheritDoc}
1724     */
1725    public int getDBCachePercent() {
1726      return impl.getPropertyValue(INSTANCE.getDBCachePercentPropertyDefinition());
1727    }
1728
1729
1730
1731    /**
1732     * {@inheritDoc}
1733     */
1734    public void setDBCachePercent(Integer value) {
1735      impl.setPropertyValue(INSTANCE.getDBCachePercentPropertyDefinition(), value);
1736    }
1737
1738
1739
1740    /**
1741     * {@inheritDoc}
1742     */
1743    public long getDBCacheSize() {
1744      return impl.getPropertyValue(INSTANCE.getDBCacheSizePropertyDefinition());
1745    }
1746
1747
1748
1749    /**
1750     * {@inheritDoc}
1751     */
1752    public void setDBCacheSize(Long value) {
1753      impl.setPropertyValue(INSTANCE.getDBCacheSizePropertyDefinition(), value);
1754    }
1755
1756
1757
1758    /**
1759     * {@inheritDoc}
1760     */
1761    public long getDBCheckpointerBytesInterval() {
1762      return impl.getPropertyValue(INSTANCE.getDBCheckpointerBytesIntervalPropertyDefinition());
1763    }
1764
1765
1766
1767    /**
1768     * {@inheritDoc}
1769     */
1770    public void setDBCheckpointerBytesInterval(Long value) {
1771      impl.setPropertyValue(INSTANCE.getDBCheckpointerBytesIntervalPropertyDefinition(), value);
1772    }
1773
1774
1775
1776    /**
1777     * {@inheritDoc}
1778     */
1779    public long getDBCheckpointerWakeupInterval() {
1780      return impl.getPropertyValue(INSTANCE.getDBCheckpointerWakeupIntervalPropertyDefinition());
1781    }
1782
1783
1784
1785    /**
1786     * {@inheritDoc}
1787     */
1788    public void setDBCheckpointerWakeupInterval(Long value) {
1789      impl.setPropertyValue(INSTANCE.getDBCheckpointerWakeupIntervalPropertyDefinition(), value);
1790    }
1791
1792
1793
1794    /**
1795     * {@inheritDoc}
1796     */
1797    public int getDBCleanerMinUtilization() {
1798      return impl.getPropertyValue(INSTANCE.getDBCleanerMinUtilizationPropertyDefinition());
1799    }
1800
1801
1802
1803    /**
1804     * {@inheritDoc}
1805     */
1806    public void setDBCleanerMinUtilization(Integer value) {
1807      impl.setPropertyValue(INSTANCE.getDBCleanerMinUtilizationPropertyDefinition(), value);
1808    }
1809
1810
1811
1812    /**
1813     * {@inheritDoc}
1814     */
1815    public String getDBDirectory() {
1816      return impl.getPropertyValue(INSTANCE.getDBDirectoryPropertyDefinition());
1817    }
1818
1819
1820
1821    /**
1822     * {@inheritDoc}
1823     */
1824    public void setDBDirectory(String value) {
1825      impl.setPropertyValue(INSTANCE.getDBDirectoryPropertyDefinition(), value);
1826    }
1827
1828
1829
1830    /**
1831     * {@inheritDoc}
1832     */
1833    public String getDBDirectoryPermissions() {
1834      return impl.getPropertyValue(INSTANCE.getDBDirectoryPermissionsPropertyDefinition());
1835    }
1836
1837
1838
1839    /**
1840     * {@inheritDoc}
1841     */
1842    public void setDBDirectoryPermissions(String value) {
1843      impl.setPropertyValue(INSTANCE.getDBDirectoryPermissionsPropertyDefinition(), value);
1844    }
1845
1846
1847
1848    /**
1849     * {@inheritDoc}
1850     */
1851    public int getDBEvictorCoreThreads() {
1852      return impl.getPropertyValue(INSTANCE.getDBEvictorCoreThreadsPropertyDefinition());
1853    }
1854
1855
1856
1857    /**
1858     * {@inheritDoc}
1859     */
1860    public void setDBEvictorCoreThreads(Integer value) {
1861      impl.setPropertyValue(INSTANCE.getDBEvictorCoreThreadsPropertyDefinition(), value);
1862    }
1863
1864
1865
1866    /**
1867     * {@inheritDoc}
1868     */
1869    public long getDBEvictorKeepAlive() {
1870      return impl.getPropertyValue(INSTANCE.getDBEvictorKeepAlivePropertyDefinition());
1871    }
1872
1873
1874
1875    /**
1876     * {@inheritDoc}
1877     */
1878    public void setDBEvictorKeepAlive(Long value) {
1879      impl.setPropertyValue(INSTANCE.getDBEvictorKeepAlivePropertyDefinition(), value);
1880    }
1881
1882
1883
1884    /**
1885     * {@inheritDoc}
1886     */
1887    public boolean isDBEvictorLruOnly() {
1888      return impl.getPropertyValue(INSTANCE.getDBEvictorLruOnlyPropertyDefinition());
1889    }
1890
1891
1892
1893    /**
1894     * {@inheritDoc}
1895     */
1896    public void setDBEvictorLruOnly(Boolean value) {
1897      impl.setPropertyValue(INSTANCE.getDBEvictorLruOnlyPropertyDefinition(), value);
1898    }
1899
1900
1901
1902    /**
1903     * {@inheritDoc}
1904     */
1905    public int getDBEvictorMaxThreads() {
1906      return impl.getPropertyValue(INSTANCE.getDBEvictorMaxThreadsPropertyDefinition());
1907    }
1908
1909
1910
1911    /**
1912     * {@inheritDoc}
1913     */
1914    public void setDBEvictorMaxThreads(Integer value) {
1915      impl.setPropertyValue(INSTANCE.getDBEvictorMaxThreadsPropertyDefinition(), value);
1916    }
1917
1918
1919
1920    /**
1921     * {@inheritDoc}
1922     */
1923    public int getDBEvictorNodesPerScan() {
1924      return impl.getPropertyValue(INSTANCE.getDBEvictorNodesPerScanPropertyDefinition());
1925    }
1926
1927
1928
1929    /**
1930     * {@inheritDoc}
1931     */
1932    public void setDBEvictorNodesPerScan(Integer value) {
1933      impl.setPropertyValue(INSTANCE.getDBEvictorNodesPerScanPropertyDefinition(), value);
1934    }
1935
1936
1937
1938    /**
1939     * {@inheritDoc}
1940     */
1941    public int getDBLogFilecacheSize() {
1942      return impl.getPropertyValue(INSTANCE.getDBLogFilecacheSizePropertyDefinition());
1943    }
1944
1945
1946
1947    /**
1948     * {@inheritDoc}
1949     */
1950    public void setDBLogFilecacheSize(Integer value) {
1951      impl.setPropertyValue(INSTANCE.getDBLogFilecacheSizePropertyDefinition(), value);
1952    }
1953
1954
1955
1956    /**
1957     * {@inheritDoc}
1958     */
1959    public long getDBLogFileMax() {
1960      return impl.getPropertyValue(INSTANCE.getDBLogFileMaxPropertyDefinition());
1961    }
1962
1963
1964
1965    /**
1966     * {@inheritDoc}
1967     */
1968    public void setDBLogFileMax(Long value) {
1969      impl.setPropertyValue(INSTANCE.getDBLogFileMaxPropertyDefinition(), value);
1970    }
1971
1972
1973
1974    /**
1975     * {@inheritDoc}
1976     */
1977    public boolean isDBLoggingFileHandlerOn() {
1978      return impl.getPropertyValue(INSTANCE.getDBLoggingFileHandlerOnPropertyDefinition());
1979    }
1980
1981
1982
1983    /**
1984     * {@inheritDoc}
1985     */
1986    public void setDBLoggingFileHandlerOn(Boolean value) {
1987      impl.setPropertyValue(INSTANCE.getDBLoggingFileHandlerOnPropertyDefinition(), value);
1988    }
1989
1990
1991
1992    /**
1993     * {@inheritDoc}
1994     */
1995    public String getDBLoggingLevel() {
1996      return impl.getPropertyValue(INSTANCE.getDBLoggingLevelPropertyDefinition());
1997    }
1998
1999
2000
2001    /**
2002     * {@inheritDoc}
2003     */
2004    public void setDBLoggingLevel(String value) {
2005      impl.setPropertyValue(INSTANCE.getDBLoggingLevelPropertyDefinition(), value);
2006    }
2007
2008
2009
2010    /**
2011     * {@inheritDoc}
2012     */
2013    public Integer getDBNumCleanerThreads() {
2014      return impl.getPropertyValue(INSTANCE.getDBNumCleanerThreadsPropertyDefinition());
2015    }
2016
2017
2018
2019    /**
2020     * {@inheritDoc}
2021     */
2022    public void setDBNumCleanerThreads(Integer value) {
2023      impl.setPropertyValue(INSTANCE.getDBNumCleanerThreadsPropertyDefinition(), value);
2024    }
2025
2026
2027
2028    /**
2029     * {@inheritDoc}
2030     */
2031    public Integer getDBNumLockTables() {
2032      return impl.getPropertyValue(INSTANCE.getDBNumLockTablesPropertyDefinition());
2033    }
2034
2035
2036
2037    /**
2038     * {@inheritDoc}
2039     */
2040    public void setDBNumLockTables(Integer value) {
2041      impl.setPropertyValue(INSTANCE.getDBNumLockTablesPropertyDefinition(), value);
2042    }
2043
2044
2045
2046    /**
2047     * {@inheritDoc}
2048     */
2049    public boolean isDBRunCleaner() {
2050      return impl.getPropertyValue(INSTANCE.getDBRunCleanerPropertyDefinition());
2051    }
2052
2053
2054
2055    /**
2056     * {@inheritDoc}
2057     */
2058    public void setDBRunCleaner(Boolean value) {
2059      impl.setPropertyValue(INSTANCE.getDBRunCleanerPropertyDefinition(), value);
2060    }
2061
2062
2063
2064    /**
2065     * {@inheritDoc}
2066     */
2067    public boolean isDBTxnNoSync() {
2068      return impl.getPropertyValue(INSTANCE.getDBTxnNoSyncPropertyDefinition());
2069    }
2070
2071
2072
2073    /**
2074     * {@inheritDoc}
2075     */
2076    public void setDBTxnNoSync(Boolean value) {
2077      impl.setPropertyValue(INSTANCE.getDBTxnNoSyncPropertyDefinition(), value);
2078    }
2079
2080
2081
2082    /**
2083     * {@inheritDoc}
2084     */
2085    public boolean isDBTxnWriteNoSync() {
2086      return impl.getPropertyValue(INSTANCE.getDBTxnWriteNoSyncPropertyDefinition());
2087    }
2088
2089
2090
2091    /**
2092     * {@inheritDoc}
2093     */
2094    public void setDBTxnWriteNoSync(Boolean value) {
2095      impl.setPropertyValue(INSTANCE.getDBTxnWriteNoSyncPropertyDefinition(), value);
2096    }
2097
2098
2099
2100    /**
2101     * {@inheritDoc}
2102     */
2103    public long getDiskFullThreshold() {
2104      return impl.getPropertyValue(INSTANCE.getDiskFullThresholdPropertyDefinition());
2105    }
2106
2107
2108
2109    /**
2110     * {@inheritDoc}
2111     */
2112    public void setDiskFullThreshold(Long value) {
2113      impl.setPropertyValue(INSTANCE.getDiskFullThresholdPropertyDefinition(), value);
2114    }
2115
2116
2117
2118    /**
2119     * {@inheritDoc}
2120     */
2121    public long getDiskLowThreshold() {
2122      return impl.getPropertyValue(INSTANCE.getDiskLowThresholdPropertyDefinition());
2123    }
2124
2125
2126
2127    /**
2128     * {@inheritDoc}
2129     */
2130    public void setDiskLowThreshold(Long value) {
2131      impl.setPropertyValue(INSTANCE.getDiskLowThresholdPropertyDefinition(), value);
2132    }
2133
2134
2135
2136    /**
2137     * {@inheritDoc}
2138     */
2139    public Boolean isEnabled() {
2140      return impl.getPropertyValue(INSTANCE.getEnabledPropertyDefinition());
2141    }
2142
2143
2144
2145    /**
2146     * {@inheritDoc}
2147     */
2148    public void setEnabled(boolean value) {
2149      impl.setPropertyValue(INSTANCE.getEnabledPropertyDefinition(), value);
2150    }
2151
2152
2153
2154    /**
2155     * {@inheritDoc}
2156     */
2157    public boolean isEntriesCompressed() {
2158      return impl.getPropertyValue(INSTANCE.getEntriesCompressedPropertyDefinition());
2159    }
2160
2161
2162
2163    /**
2164     * {@inheritDoc}
2165     */
2166    public void setEntriesCompressed(Boolean value) {
2167      impl.setPropertyValue(INSTANCE.getEntriesCompressedPropertyDefinition(), value);
2168    }
2169
2170
2171
2172    /**
2173     * {@inheritDoc}
2174     */
2175    public int getImportQueueSize() {
2176      return impl.getPropertyValue(INSTANCE.getImportQueueSizePropertyDefinition());
2177    }
2178
2179
2180
2181    /**
2182     * {@inheritDoc}
2183     */
2184    public void setImportQueueSize(Integer value) {
2185      impl.setPropertyValue(INSTANCE.getImportQueueSizePropertyDefinition(), value);
2186    }
2187
2188
2189
2190    /**
2191     * {@inheritDoc}
2192     */
2193    public int getImportThreadCount() {
2194      return impl.getPropertyValue(INSTANCE.getImportThreadCountPropertyDefinition());
2195    }
2196
2197
2198
2199    /**
2200     * {@inheritDoc}
2201     */
2202    public void setImportThreadCount(Integer value) {
2203      impl.setPropertyValue(INSTANCE.getImportThreadCountPropertyDefinition(), value);
2204    }
2205
2206
2207
2208    /**
2209     * {@inheritDoc}
2210     */
2211    public int getIndexEntryLimit() {
2212      return impl.getPropertyValue(INSTANCE.getIndexEntryLimitPropertyDefinition());
2213    }
2214
2215
2216
2217    /**
2218     * {@inheritDoc}
2219     */
2220    public void setIndexEntryLimit(Integer value) {
2221      impl.setPropertyValue(INSTANCE.getIndexEntryLimitPropertyDefinition(), value);
2222    }
2223
2224
2225
2226    /**
2227     * {@inheritDoc}
2228     */
2229    public boolean isIndexFilterAnalyzerEnabled() {
2230      return impl.getPropertyValue(INSTANCE.getIndexFilterAnalyzerEnabledPropertyDefinition());
2231    }
2232
2233
2234
2235    /**
2236     * {@inheritDoc}
2237     */
2238    public void setIndexFilterAnalyzerEnabled(Boolean value) {
2239      impl.setPropertyValue(INSTANCE.getIndexFilterAnalyzerEnabledPropertyDefinition(), value);
2240    }
2241
2242
2243
2244    /**
2245     * {@inheritDoc}
2246     */
2247    public int getIndexFilterAnalyzerMaxFilters() {
2248      return impl.getPropertyValue(INSTANCE.getIndexFilterAnalyzerMaxFiltersPropertyDefinition());
2249    }
2250
2251
2252
2253    /**
2254     * {@inheritDoc}
2255     */
2256    public void setIndexFilterAnalyzerMaxFilters(Integer value) {
2257      impl.setPropertyValue(INSTANCE.getIndexFilterAnalyzerMaxFiltersPropertyDefinition(), value);
2258    }
2259
2260
2261
2262    /**
2263     * {@inheritDoc}
2264     */
2265    public String getJavaClass() {
2266      return impl.getPropertyValue(INSTANCE.getJavaClassPropertyDefinition());
2267    }
2268
2269
2270
2271    /**
2272     * {@inheritDoc}
2273     */
2274    public void setJavaClass(String value) {
2275      impl.setPropertyValue(INSTANCE.getJavaClassPropertyDefinition(), value);
2276    }
2277
2278
2279
2280    /**
2281     * {@inheritDoc}
2282     */
2283    public SortedSet<String> getJEProperty() {
2284      return impl.getPropertyValues(INSTANCE.getJEPropertyPropertyDefinition());
2285    }
2286
2287
2288
2289    /**
2290     * {@inheritDoc}
2291     */
2292    public void setJEProperty(Collection<String> values) {
2293      impl.setPropertyValues(INSTANCE.getJEPropertyPropertyDefinition(), values);
2294    }
2295
2296
2297
2298    /**
2299     * {@inheritDoc}
2300     */
2301    public long getPreloadTimeLimit() {
2302      return impl.getPropertyValue(INSTANCE.getPreloadTimeLimitPropertyDefinition());
2303    }
2304
2305
2306
2307    /**
2308     * {@inheritDoc}
2309     */
2310    public void setPreloadTimeLimit(Long value) {
2311      impl.setPropertyValue(INSTANCE.getPreloadTimeLimitPropertyDefinition(), value);
2312    }
2313
2314
2315
2316    /**
2317     * {@inheritDoc}
2318     */
2319    public boolean isSubordinateIndexesEnabled() {
2320      return impl.getPropertyValue(INSTANCE.getSubordinateIndexesEnabledPropertyDefinition());
2321    }
2322
2323
2324
2325    /**
2326     * {@inheritDoc}
2327     */
2328    public void setSubordinateIndexesEnabled(Boolean value) {
2329      impl.setPropertyValue(INSTANCE.getSubordinateIndexesEnabledPropertyDefinition(), value);
2330    }
2331
2332
2333
2334    /**
2335     * {@inheritDoc}
2336     */
2337    public WritabilityMode getWritabilityMode() {
2338      return impl.getPropertyValue(INSTANCE.getWritabilityModePropertyDefinition());
2339    }
2340
2341
2342
2343    /**
2344     * {@inheritDoc}
2345     */
2346    public void setWritabilityMode(WritabilityMode value) {
2347      impl.setPropertyValue(INSTANCE.getWritabilityModePropertyDefinition(), value);
2348    }
2349
2350
2351
2352    /**
2353     * {@inheritDoc}
2354     */
2355    public String[] listLocalDBIndexes() throws ConcurrentModificationException,
2356        LdapException {
2357      return impl.listChildren(INSTANCE.getLocalDBIndexesRelationDefinition());
2358    }
2359
2360
2361
2362    /**
2363     * {@inheritDoc}
2364     */
2365    public LocalDBIndexCfgClient getLocalDBIndex(String name)
2366        throws DefinitionDecodingException, ManagedObjectDecodingException,
2367        ManagedObjectNotFoundException, ConcurrentModificationException,
2368        LdapException {
2369      return impl.getChild(INSTANCE.getLocalDBIndexesRelationDefinition(), name).getConfiguration();
2370    }
2371
2372
2373
2374    /**
2375     * {@inheritDoc}
2376     */
2377    public <M extends LocalDBIndexCfgClient> M createLocalDBIndex(
2378        ManagedObjectDefinition<M, ? extends LocalDBIndexCfg> d, String name, Collection<PropertyException> exceptions) throws IllegalManagedObjectNameException {
2379      return impl.createChild(INSTANCE.getLocalDBIndexesRelationDefinition(), d, name, exceptions).getConfiguration();
2380    }
2381
2382
2383
2384    /**
2385     * {@inheritDoc}
2386     */
2387    public void removeLocalDBIndex(String name)
2388        throws ManagedObjectNotFoundException, ConcurrentModificationException,
2389        OperationRejectedException, LdapException {
2390      impl.removeChild(INSTANCE.getLocalDBIndexesRelationDefinition(), name);
2391    }
2392
2393
2394
2395    /**
2396     * {@inheritDoc}
2397     */
2398    public String[] listLocalDBVLVIndexes() throws ConcurrentModificationException,
2399        LdapException {
2400      return impl.listChildren(INSTANCE.getLocalDBVLVIndexesRelationDefinition());
2401    }
2402
2403
2404
2405    /**
2406     * {@inheritDoc}
2407     */
2408    public LocalDBVLVIndexCfgClient getLocalDBVLVIndex(String name)
2409        throws DefinitionDecodingException, ManagedObjectDecodingException,
2410        ManagedObjectNotFoundException, ConcurrentModificationException,
2411        LdapException {
2412      return impl.getChild(INSTANCE.getLocalDBVLVIndexesRelationDefinition(), name).getConfiguration();
2413    }
2414
2415
2416
2417    /**
2418     * {@inheritDoc}
2419     */
2420    public <M extends LocalDBVLVIndexCfgClient> M createLocalDBVLVIndex(
2421        ManagedObjectDefinition<M, ? extends LocalDBVLVIndexCfg> d, String name, Collection<PropertyException> exceptions) throws IllegalManagedObjectNameException {
2422      return impl.createChild(INSTANCE.getLocalDBVLVIndexesRelationDefinition(), d, name, exceptions).getConfiguration();
2423    }
2424
2425
2426
2427    /**
2428     * {@inheritDoc}
2429     */
2430    public void removeLocalDBVLVIndex(String name)
2431        throws ManagedObjectNotFoundException, ConcurrentModificationException,
2432        OperationRejectedException, LdapException {
2433      impl.removeChild(INSTANCE.getLocalDBVLVIndexesRelationDefinition(), name);
2434    }
2435
2436
2437
2438    /**
2439     * {@inheritDoc}
2440     */
2441    public ManagedObjectDefinition<? extends LocalDBBackendCfgClient, ? extends LocalDBBackendCfg> definition() {
2442      return INSTANCE;
2443    }
2444
2445
2446
2447    /**
2448     * {@inheritDoc}
2449     */
2450    public PropertyProvider properties() {
2451      return impl;
2452    }
2453
2454
2455
2456    /**
2457     * {@inheritDoc}
2458     */
2459    public void commit() throws ManagedObjectAlreadyExistsException,
2460        MissingMandatoryPropertiesException, ConcurrentModificationException,
2461        OperationRejectedException, LdapException {
2462      impl.commit();
2463    }
2464
2465  }
2466
2467
2468
2469  /**
2470   * Managed object server implementation.
2471   */
2472  private static class LocalDBBackendCfgServerImpl implements
2473    LocalDBBackendCfg {
2474
2475    // Private implementation.
2476    private ServerManagedObject<? extends LocalDBBackendCfg> impl;
2477
2478    // The value of the "backend-id" property.
2479    private final String pBackendId;
2480
2481    // The value of the "base-dn" property.
2482    private final SortedSet<DN> pBaseDN;
2483
2484    // The value of the "compact-encoding" property.
2485    private final boolean pCompactEncoding;
2486
2487    // The value of the "db-cache-percent" property.
2488    private final int pDBCachePercent;
2489
2490    // The value of the "db-cache-size" property.
2491    private final long pDBCacheSize;
2492
2493    // The value of the "db-checkpointer-bytes-interval" property.
2494    private final long pDBCheckpointerBytesInterval;
2495
2496    // The value of the "db-checkpointer-wakeup-interval" property.
2497    private final long pDBCheckpointerWakeupInterval;
2498
2499    // The value of the "db-cleaner-min-utilization" property.
2500    private final int pDBCleanerMinUtilization;
2501
2502    // The value of the "db-directory" property.
2503    private final String pDBDirectory;
2504
2505    // The value of the "db-directory-permissions" property.
2506    private final String pDBDirectoryPermissions;
2507
2508    // The value of the "db-evictor-core-threads" property.
2509    private final int pDBEvictorCoreThreads;
2510
2511    // The value of the "db-evictor-keep-alive" property.
2512    private final long pDBEvictorKeepAlive;
2513
2514    // The value of the "db-evictor-lru-only" property.
2515    private final boolean pDBEvictorLruOnly;
2516
2517    // The value of the "db-evictor-max-threads" property.
2518    private final int pDBEvictorMaxThreads;
2519
2520    // The value of the "db-evictor-nodes-per-scan" property.
2521    private final int pDBEvictorNodesPerScan;
2522
2523    // The value of the "db-log-filecache-size" property.
2524    private final int pDBLogFilecacheSize;
2525
2526    // The value of the "db-log-file-max" property.
2527    private final long pDBLogFileMax;
2528
2529    // The value of the "db-logging-file-handler-on" property.
2530    private final boolean pDBLoggingFileHandlerOn;
2531
2532    // The value of the "db-logging-level" property.
2533    private final String pDBLoggingLevel;
2534
2535    // The value of the "db-num-cleaner-threads" property.
2536    private final Integer pDBNumCleanerThreads;
2537
2538    // The value of the "db-num-lock-tables" property.
2539    private final Integer pDBNumLockTables;
2540
2541    // The value of the "db-run-cleaner" property.
2542    private final boolean pDBRunCleaner;
2543
2544    // The value of the "db-txn-no-sync" property.
2545    private final boolean pDBTxnNoSync;
2546
2547    // The value of the "db-txn-write-no-sync" property.
2548    private final boolean pDBTxnWriteNoSync;
2549
2550    // The value of the "disk-full-threshold" property.
2551    private final long pDiskFullThreshold;
2552
2553    // The value of the "disk-low-threshold" property.
2554    private final long pDiskLowThreshold;
2555
2556    // The value of the "enabled" property.
2557    private final boolean pEnabled;
2558
2559    // The value of the "entries-compressed" property.
2560    private final boolean pEntriesCompressed;
2561
2562    // The value of the "import-queue-size" property.
2563    private final int pImportQueueSize;
2564
2565    // The value of the "import-thread-count" property.
2566    private final int pImportThreadCount;
2567
2568    // The value of the "index-entry-limit" property.
2569    private final int pIndexEntryLimit;
2570
2571    // The value of the "index-filter-analyzer-enabled" property.
2572    private final boolean pIndexFilterAnalyzerEnabled;
2573
2574    // The value of the "index-filter-analyzer-max-filters" property.
2575    private final int pIndexFilterAnalyzerMaxFilters;
2576
2577    // The value of the "java-class" property.
2578    private final String pJavaClass;
2579
2580    // The value of the "je-property" property.
2581    private final SortedSet<String> pJEProperty;
2582
2583    // The value of the "preload-time-limit" property.
2584    private final long pPreloadTimeLimit;
2585
2586    // The value of the "subordinate-indexes-enabled" property.
2587    private final boolean pSubordinateIndexesEnabled;
2588
2589    // The value of the "writability-mode" property.
2590    private final WritabilityMode pWritabilityMode;
2591
2592
2593
2594    // Private constructor.
2595    private LocalDBBackendCfgServerImpl(ServerManagedObject<? extends LocalDBBackendCfg> impl) {
2596      this.impl = impl;
2597      this.pBackendId = impl.getPropertyValue(INSTANCE.getBackendIdPropertyDefinition());
2598      this.pBaseDN = impl.getPropertyValues(INSTANCE.getBaseDNPropertyDefinition());
2599      this.pCompactEncoding = impl.getPropertyValue(INSTANCE.getCompactEncodingPropertyDefinition());
2600      this.pDBCachePercent = impl.getPropertyValue(INSTANCE.getDBCachePercentPropertyDefinition());
2601      this.pDBCacheSize = impl.getPropertyValue(INSTANCE.getDBCacheSizePropertyDefinition());
2602      this.pDBCheckpointerBytesInterval = impl.getPropertyValue(INSTANCE.getDBCheckpointerBytesIntervalPropertyDefinition());
2603      this.pDBCheckpointerWakeupInterval = impl.getPropertyValue(INSTANCE.getDBCheckpointerWakeupIntervalPropertyDefinition());
2604      this.pDBCleanerMinUtilization = impl.getPropertyValue(INSTANCE.getDBCleanerMinUtilizationPropertyDefinition());
2605      this.pDBDirectory = impl.getPropertyValue(INSTANCE.getDBDirectoryPropertyDefinition());
2606      this.pDBDirectoryPermissions = impl.getPropertyValue(INSTANCE.getDBDirectoryPermissionsPropertyDefinition());
2607      this.pDBEvictorCoreThreads = impl.getPropertyValue(INSTANCE.getDBEvictorCoreThreadsPropertyDefinition());
2608      this.pDBEvictorKeepAlive = impl.getPropertyValue(INSTANCE.getDBEvictorKeepAlivePropertyDefinition());
2609      this.pDBEvictorLruOnly = impl.getPropertyValue(INSTANCE.getDBEvictorLruOnlyPropertyDefinition());
2610      this.pDBEvictorMaxThreads = impl.getPropertyValue(INSTANCE.getDBEvictorMaxThreadsPropertyDefinition());
2611      this.pDBEvictorNodesPerScan = impl.getPropertyValue(INSTANCE.getDBEvictorNodesPerScanPropertyDefinition());
2612      this.pDBLogFilecacheSize = impl.getPropertyValue(INSTANCE.getDBLogFilecacheSizePropertyDefinition());
2613      this.pDBLogFileMax = impl.getPropertyValue(INSTANCE.getDBLogFileMaxPropertyDefinition());
2614      this.pDBLoggingFileHandlerOn = impl.getPropertyValue(INSTANCE.getDBLoggingFileHandlerOnPropertyDefinition());
2615      this.pDBLoggingLevel = impl.getPropertyValue(INSTANCE.getDBLoggingLevelPropertyDefinition());
2616      this.pDBNumCleanerThreads = impl.getPropertyValue(INSTANCE.getDBNumCleanerThreadsPropertyDefinition());
2617      this.pDBNumLockTables = impl.getPropertyValue(INSTANCE.getDBNumLockTablesPropertyDefinition());
2618      this.pDBRunCleaner = impl.getPropertyValue(INSTANCE.getDBRunCleanerPropertyDefinition());
2619      this.pDBTxnNoSync = impl.getPropertyValue(INSTANCE.getDBTxnNoSyncPropertyDefinition());
2620      this.pDBTxnWriteNoSync = impl.getPropertyValue(INSTANCE.getDBTxnWriteNoSyncPropertyDefinition());
2621      this.pDiskFullThreshold = impl.getPropertyValue(INSTANCE.getDiskFullThresholdPropertyDefinition());
2622      this.pDiskLowThreshold = impl.getPropertyValue(INSTANCE.getDiskLowThresholdPropertyDefinition());
2623      this.pEnabled = impl.getPropertyValue(INSTANCE.getEnabledPropertyDefinition());
2624      this.pEntriesCompressed = impl.getPropertyValue(INSTANCE.getEntriesCompressedPropertyDefinition());
2625      this.pImportQueueSize = impl.getPropertyValue(INSTANCE.getImportQueueSizePropertyDefinition());
2626      this.pImportThreadCount = impl.getPropertyValue(INSTANCE.getImportThreadCountPropertyDefinition());
2627      this.pIndexEntryLimit = impl.getPropertyValue(INSTANCE.getIndexEntryLimitPropertyDefinition());
2628      this.pIndexFilterAnalyzerEnabled = impl.getPropertyValue(INSTANCE.getIndexFilterAnalyzerEnabledPropertyDefinition());
2629      this.pIndexFilterAnalyzerMaxFilters = impl.getPropertyValue(INSTANCE.getIndexFilterAnalyzerMaxFiltersPropertyDefinition());
2630      this.pJavaClass = impl.getPropertyValue(INSTANCE.getJavaClassPropertyDefinition());
2631      this.pJEProperty = impl.getPropertyValues(INSTANCE.getJEPropertyPropertyDefinition());
2632      this.pPreloadTimeLimit = impl.getPropertyValue(INSTANCE.getPreloadTimeLimitPropertyDefinition());
2633      this.pSubordinateIndexesEnabled = impl.getPropertyValue(INSTANCE.getSubordinateIndexesEnabledPropertyDefinition());
2634      this.pWritabilityMode = impl.getPropertyValue(INSTANCE.getWritabilityModePropertyDefinition());
2635    }
2636
2637
2638
2639    /**
2640     * {@inheritDoc}
2641     */
2642    public void addLocalDBChangeListener(
2643        ConfigurationChangeListener<LocalDBBackendCfg> listener) {
2644      impl.registerChangeListener(listener);
2645    }
2646
2647
2648
2649    /**
2650     * {@inheritDoc}
2651     */
2652    public void removeLocalDBChangeListener(
2653        ConfigurationChangeListener<LocalDBBackendCfg> listener) {
2654      impl.deregisterChangeListener(listener);
2655    }
2656    /**
2657     * {@inheritDoc}
2658     */
2659    public void addChangeListener(
2660        ConfigurationChangeListener<BackendCfg> listener) {
2661      impl.registerChangeListener(listener);
2662    }
2663
2664
2665
2666    /**
2667     * {@inheritDoc}
2668     */
2669    public void removeChangeListener(
2670        ConfigurationChangeListener<BackendCfg> listener) {
2671      impl.deregisterChangeListener(listener);
2672    }
2673
2674
2675
2676    /**
2677     * {@inheritDoc}
2678     */
2679    public String getBackendId() {
2680      return pBackendId;
2681    }
2682
2683
2684
2685    /**
2686     * {@inheritDoc}
2687     */
2688    public SortedSet<DN> getBaseDN() {
2689      return pBaseDN;
2690    }
2691
2692
2693
2694    /**
2695     * {@inheritDoc}
2696     */
2697    public boolean isCompactEncoding() {
2698      return pCompactEncoding;
2699    }
2700
2701
2702
2703    /**
2704     * {@inheritDoc}
2705     */
2706    public int getDBCachePercent() {
2707      return pDBCachePercent;
2708    }
2709
2710
2711
2712    /**
2713     * {@inheritDoc}
2714     */
2715    public long getDBCacheSize() {
2716      return pDBCacheSize;
2717    }
2718
2719
2720
2721    /**
2722     * {@inheritDoc}
2723     */
2724    public long getDBCheckpointerBytesInterval() {
2725      return pDBCheckpointerBytesInterval;
2726    }
2727
2728
2729
2730    /**
2731     * {@inheritDoc}
2732     */
2733    public long getDBCheckpointerWakeupInterval() {
2734      return pDBCheckpointerWakeupInterval;
2735    }
2736
2737
2738
2739    /**
2740     * {@inheritDoc}
2741     */
2742    public int getDBCleanerMinUtilization() {
2743      return pDBCleanerMinUtilization;
2744    }
2745
2746
2747
2748    /**
2749     * {@inheritDoc}
2750     */
2751    public String getDBDirectory() {
2752      return pDBDirectory;
2753    }
2754
2755
2756
2757    /**
2758     * {@inheritDoc}
2759     */
2760    public String getDBDirectoryPermissions() {
2761      return pDBDirectoryPermissions;
2762    }
2763
2764
2765
2766    /**
2767     * {@inheritDoc}
2768     */
2769    public int getDBEvictorCoreThreads() {
2770      return pDBEvictorCoreThreads;
2771    }
2772
2773
2774
2775    /**
2776     * {@inheritDoc}
2777     */
2778    public long getDBEvictorKeepAlive() {
2779      return pDBEvictorKeepAlive;
2780    }
2781
2782
2783
2784    /**
2785     * {@inheritDoc}
2786     */
2787    public boolean isDBEvictorLruOnly() {
2788      return pDBEvictorLruOnly;
2789    }
2790
2791
2792
2793    /**
2794     * {@inheritDoc}
2795     */
2796    public int getDBEvictorMaxThreads() {
2797      return pDBEvictorMaxThreads;
2798    }
2799
2800
2801
2802    /**
2803     * {@inheritDoc}
2804     */
2805    public int getDBEvictorNodesPerScan() {
2806      return pDBEvictorNodesPerScan;
2807    }
2808
2809
2810
2811    /**
2812     * {@inheritDoc}
2813     */
2814    public int getDBLogFilecacheSize() {
2815      return pDBLogFilecacheSize;
2816    }
2817
2818
2819
2820    /**
2821     * {@inheritDoc}
2822     */
2823    public long getDBLogFileMax() {
2824      return pDBLogFileMax;
2825    }
2826
2827
2828
2829    /**
2830     * {@inheritDoc}
2831     */
2832    public boolean isDBLoggingFileHandlerOn() {
2833      return pDBLoggingFileHandlerOn;
2834    }
2835
2836
2837
2838    /**
2839     * {@inheritDoc}
2840     */
2841    public String getDBLoggingLevel() {
2842      return pDBLoggingLevel;
2843    }
2844
2845
2846
2847    /**
2848     * {@inheritDoc}
2849     */
2850    public Integer getDBNumCleanerThreads() {
2851      return pDBNumCleanerThreads;
2852    }
2853
2854
2855
2856    /**
2857     * {@inheritDoc}
2858     */
2859    public Integer getDBNumLockTables() {
2860      return pDBNumLockTables;
2861    }
2862
2863
2864
2865    /**
2866     * {@inheritDoc}
2867     */
2868    public boolean isDBRunCleaner() {
2869      return pDBRunCleaner;
2870    }
2871
2872
2873
2874    /**
2875     * {@inheritDoc}
2876     */
2877    public boolean isDBTxnNoSync() {
2878      return pDBTxnNoSync;
2879    }
2880
2881
2882
2883    /**
2884     * {@inheritDoc}
2885     */
2886    public boolean isDBTxnWriteNoSync() {
2887      return pDBTxnWriteNoSync;
2888    }
2889
2890
2891
2892    /**
2893     * {@inheritDoc}
2894     */
2895    public long getDiskFullThreshold() {
2896      return pDiskFullThreshold;
2897    }
2898
2899
2900
2901    /**
2902     * {@inheritDoc}
2903     */
2904    public long getDiskLowThreshold() {
2905      return pDiskLowThreshold;
2906    }
2907
2908
2909
2910    /**
2911     * {@inheritDoc}
2912     */
2913    public boolean isEnabled() {
2914      return pEnabled;
2915    }
2916
2917
2918
2919    /**
2920     * {@inheritDoc}
2921     */
2922    public boolean isEntriesCompressed() {
2923      return pEntriesCompressed;
2924    }
2925
2926
2927
2928    /**
2929     * {@inheritDoc}
2930     */
2931    public int getImportQueueSize() {
2932      return pImportQueueSize;
2933    }
2934
2935
2936
2937    /**
2938     * {@inheritDoc}
2939     */
2940    public int getImportThreadCount() {
2941      return pImportThreadCount;
2942    }
2943
2944
2945
2946    /**
2947     * {@inheritDoc}
2948     */
2949    public int getIndexEntryLimit() {
2950      return pIndexEntryLimit;
2951    }
2952
2953
2954
2955    /**
2956     * {@inheritDoc}
2957     */
2958    public boolean isIndexFilterAnalyzerEnabled() {
2959      return pIndexFilterAnalyzerEnabled;
2960    }
2961
2962
2963
2964    /**
2965     * {@inheritDoc}
2966     */
2967    public int getIndexFilterAnalyzerMaxFilters() {
2968      return pIndexFilterAnalyzerMaxFilters;
2969    }
2970
2971
2972
2973    /**
2974     * {@inheritDoc}
2975     */
2976    public String getJavaClass() {
2977      return pJavaClass;
2978    }
2979
2980
2981
2982    /**
2983     * {@inheritDoc}
2984     */
2985    public SortedSet<String> getJEProperty() {
2986      return pJEProperty;
2987    }
2988
2989
2990
2991    /**
2992     * {@inheritDoc}
2993     */
2994    public long getPreloadTimeLimit() {
2995      return pPreloadTimeLimit;
2996    }
2997
2998
2999
3000    /**
3001     * {@inheritDoc}
3002     */
3003    public boolean isSubordinateIndexesEnabled() {
3004      return pSubordinateIndexesEnabled;
3005    }
3006
3007
3008
3009    /**
3010     * {@inheritDoc}
3011     */
3012    public WritabilityMode getWritabilityMode() {
3013      return pWritabilityMode;
3014    }
3015
3016
3017
3018    /**
3019     * {@inheritDoc}
3020     */
3021    public String[] listLocalDBIndexes() {
3022      return impl.listChildren(INSTANCE.getLocalDBIndexesRelationDefinition());
3023    }
3024
3025
3026
3027    /**
3028     * {@inheritDoc}
3029     */
3030    public LocalDBIndexCfg getLocalDBIndex(String name) throws ConfigException {
3031      return impl.getChild(INSTANCE.getLocalDBIndexesRelationDefinition(), name).getConfiguration();
3032    }
3033
3034
3035
3036    /**
3037     * {@inheritDoc}
3038     */
3039    public void addLocalDBIndexAddListener(
3040        ConfigurationAddListener<LocalDBIndexCfg> listener) throws ConfigException {
3041      impl.registerAddListener(INSTANCE.getLocalDBIndexesRelationDefinition(), listener);
3042    }
3043
3044
3045
3046    /**
3047     * {@inheritDoc}
3048     */
3049    public void removeLocalDBIndexAddListener(
3050        ConfigurationAddListener<LocalDBIndexCfg> listener) {
3051      impl.deregisterAddListener(INSTANCE.getLocalDBIndexesRelationDefinition(), listener);
3052    }
3053
3054
3055
3056    /**
3057     * {@inheritDoc}
3058     */
3059    public void addLocalDBIndexDeleteListener(
3060        ConfigurationDeleteListener<LocalDBIndexCfg> listener) throws ConfigException {
3061      impl.registerDeleteListener(INSTANCE.getLocalDBIndexesRelationDefinition(), listener);
3062    }
3063
3064
3065
3066    /**
3067     * {@inheritDoc}
3068     */
3069    public void removeLocalDBIndexDeleteListener(
3070        ConfigurationDeleteListener<LocalDBIndexCfg> listener) {
3071      impl.deregisterDeleteListener(INSTANCE.getLocalDBIndexesRelationDefinition(), listener);
3072    }
3073
3074
3075
3076    /**
3077     * {@inheritDoc}
3078     */
3079    public String[] listLocalDBVLVIndexes() {
3080      return impl.listChildren(INSTANCE.getLocalDBVLVIndexesRelationDefinition());
3081    }
3082
3083
3084
3085    /**
3086     * {@inheritDoc}
3087     */
3088    public LocalDBVLVIndexCfg getLocalDBVLVIndex(String name) throws ConfigException {
3089      return impl.getChild(INSTANCE.getLocalDBVLVIndexesRelationDefinition(), name).getConfiguration();
3090    }
3091
3092
3093
3094    /**
3095     * {@inheritDoc}
3096     */
3097    public void addLocalDBVLVIndexAddListener(
3098        ConfigurationAddListener<LocalDBVLVIndexCfg> listener) throws ConfigException {
3099      impl.registerAddListener(INSTANCE.getLocalDBVLVIndexesRelationDefinition(), listener);
3100    }
3101
3102
3103
3104    /**
3105     * {@inheritDoc}
3106     */
3107    public void removeLocalDBVLVIndexAddListener(
3108        ConfigurationAddListener<LocalDBVLVIndexCfg> listener) {
3109      impl.deregisterAddListener(INSTANCE.getLocalDBVLVIndexesRelationDefinition(), listener);
3110    }
3111
3112
3113
3114    /**
3115     * {@inheritDoc}
3116     */
3117    public void addLocalDBVLVIndexDeleteListener(
3118        ConfigurationDeleteListener<LocalDBVLVIndexCfg> listener) throws ConfigException {
3119      impl.registerDeleteListener(INSTANCE.getLocalDBVLVIndexesRelationDefinition(), listener);
3120    }
3121
3122
3123
3124    /**
3125     * {@inheritDoc}
3126     */
3127    public void removeLocalDBVLVIndexDeleteListener(
3128        ConfigurationDeleteListener<LocalDBVLVIndexCfg> listener) {
3129      impl.deregisterDeleteListener(INSTANCE.getLocalDBVLVIndexesRelationDefinition(), listener);
3130    }
3131
3132
3133
3134    /**
3135     * {@inheritDoc}
3136     */
3137    public Class<? extends LocalDBBackendCfg> configurationClass() {
3138      return LocalDBBackendCfg.class;
3139    }
3140
3141
3142
3143    /**
3144     * {@inheritDoc}
3145     */
3146    public DN dn() {
3147      return impl.getDN();
3148    }
3149
3150  }
3151}