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