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