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