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