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