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 }