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 }