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