001/* 002 * CDDL HEADER START 003 * 004 * The contents of this file are subject to the terms of the 005 * Common Development and Distribution License, Version 1.0 only 006 * (the "License"). You may not use this file except in compliance 007 * with the License. 008 * 009 * You can obtain a copy of the license at legal-notices/CDDLv1_0.txt 010 * or http://forgerock.org/license/CDDLv1.0.html. 011 * See the License for the specific language governing permissions 012 * and limitations under the License. 013 * 014 * When distributing Covered Code, include this CDDL HEADER in each 015 * file and include the License file at legal-notices/CDDLv1_0.txt. 016 * If applicable, add the following below this CDDL HEADER, with the 017 * fields enclosed by brackets "[]" replaced with your own identifying 018 * information: 019 * Portions Copyright [yyyy] [name of copyright owner] 020 * 021 * CDDL HEADER END 022 * 023 * 024 * Copyright 2008 Sun Microsystems, Inc. 025 */ 026package org.forgerock.opendj.server.config.meta; 027 028 029 030import java.util.Collection; 031import java.util.SortedSet; 032import org.forgerock.opendj.config.AdministratorAction; 033import org.forgerock.opendj.config.BooleanPropertyDefinition; 034import org.forgerock.opendj.config.ClassPropertyDefinition; 035import org.forgerock.opendj.config.client.ConcurrentModificationException; 036import org.forgerock.opendj.config.client.IllegalManagedObjectNameException; 037import org.forgerock.opendj.config.client.ManagedObject; 038import org.forgerock.opendj.config.client.ManagedObjectDecodingException; 039import org.forgerock.opendj.config.client.MissingMandatoryPropertiesException; 040import org.forgerock.opendj.config.client.OperationRejectedException; 041import org.forgerock.opendj.config.DefaultBehaviorProvider; 042import org.forgerock.opendj.config.DefinedDefaultBehaviorProvider; 043import org.forgerock.opendj.config.DefinitionDecodingException; 044import org.forgerock.opendj.config.DNPropertyDefinition; 045import org.forgerock.opendj.config.DurationPropertyDefinition; 046import org.forgerock.opendj.config.EnumPropertyDefinition; 047import org.forgerock.opendj.config.InstantiableRelationDefinition; 048import org.forgerock.opendj.config.IntegerPropertyDefinition; 049import org.forgerock.opendj.config.ManagedObjectAlreadyExistsException; 050import org.forgerock.opendj.config.ManagedObjectDefinition; 051import org.forgerock.opendj.config.ManagedObjectNotFoundException; 052import org.forgerock.opendj.config.PropertyException; 053import org.forgerock.opendj.config.PropertyOption; 054import org.forgerock.opendj.config.PropertyProvider; 055import org.forgerock.opendj.config.server.ConfigException; 056import org.forgerock.opendj.config.server.ConfigurationAddListener; 057import org.forgerock.opendj.config.server.ConfigurationChangeListener; 058import org.forgerock.opendj.config.server.ConfigurationDeleteListener; 059import org.forgerock.opendj.config.server.ServerManagedObject; 060import org.forgerock.opendj.config.SizePropertyDefinition; 061import org.forgerock.opendj.config.StringPropertyDefinition; 062import org.forgerock.opendj.config.Tag; 063import org.forgerock.opendj.ldap.DN; 064import org.forgerock.opendj.ldap.LdapException; 065import org.forgerock.opendj.server.config.client.BackendIndexCfgClient; 066import org.forgerock.opendj.server.config.client.BackendVLVIndexCfgClient; 067import org.forgerock.opendj.server.config.client.PDBBackendCfgClient; 068import org.forgerock.opendj.server.config.meta.BackendCfgDefn.WritabilityMode; 069import org.forgerock.opendj.server.config.server.BackendCfg; 070import org.forgerock.opendj.server.config.server.BackendIndexCfg; 071import org.forgerock.opendj.server.config.server.BackendVLVIndexCfg; 072import org.forgerock.opendj.server.config.server.PDBBackendCfg; 073import org.forgerock.opendj.server.config.server.PluggableBackendCfg; 074 075 076 077/** 078 * An interface for querying the PDB Backend managed object definition 079 * meta information. 080 * <p> 081 * A PDB Backend stores application data in a Persistit database. 082 */ 083public final class PDBBackendCfgDefn extends ManagedObjectDefinition<PDBBackendCfgClient, PDBBackendCfg> { 084 085 // The singleton configuration definition instance. 086 private static final PDBBackendCfgDefn INSTANCE = new PDBBackendCfgDefn(); 087 088 089 090 // The "db-cache-percent" property definition. 091 private static final IntegerPropertyDefinition PD_DB_CACHE_PERCENT; 092 093 094 095 // The "db-cache-size" property definition. 096 private static final SizePropertyDefinition PD_DB_CACHE_SIZE; 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-directory" property definition. 106 private static final StringPropertyDefinition PD_DB_DIRECTORY; 107 108 109 110 // The "db-directory-permissions" property definition. 111 private static final StringPropertyDefinition PD_DB_DIRECTORY_PERMISSIONS; 112 113 114 115 // The "db-txn-no-sync" property definition. 116 private static final BooleanPropertyDefinition PD_DB_TXN_NO_SYNC; 117 118 119 120 // The "disk-full-threshold" property definition. 121 private static final SizePropertyDefinition PD_DISK_FULL_THRESHOLD; 122 123 124 125 // The "disk-low-threshold" property definition. 126 private static final SizePropertyDefinition PD_DISK_LOW_THRESHOLD; 127 128 129 130 // The "java-class" property definition. 131 private static final ClassPropertyDefinition PD_JAVA_CLASS; 132 133 134 135 // Build the "db-cache-percent" property definition. 136 static { 137 IntegerPropertyDefinition.Builder builder = IntegerPropertyDefinition.createBuilder(INSTANCE, "db-cache-percent"); 138 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "db-cache-percent")); 139 DefaultBehaviorProvider<Integer> provider = new DefinedDefaultBehaviorProvider<Integer>("50"); 140 builder.setDefaultBehaviorProvider(provider); 141 builder.setUpperLimit(90); 142 builder.setLowerLimit(1); 143 PD_DB_CACHE_PERCENT = builder.getInstance(); 144 INSTANCE.registerPropertyDefinition(PD_DB_CACHE_PERCENT); 145 } 146 147 148 149 // Build the "db-cache-size" property definition. 150 static { 151 SizePropertyDefinition.Builder builder = SizePropertyDefinition.createBuilder(INSTANCE, "db-cache-size"); 152 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "db-cache-size")); 153 DefaultBehaviorProvider<Long> provider = new DefinedDefaultBehaviorProvider<Long>("0 MB"); 154 builder.setDefaultBehaviorProvider(provider); 155 builder.setLowerLimit("0 MB"); 156 PD_DB_CACHE_SIZE = builder.getInstance(); 157 INSTANCE.registerPropertyDefinition(PD_DB_CACHE_SIZE); 158 } 159 160 161 162 // Build the "db-checkpointer-wakeup-interval" property definition. 163 static { 164 DurationPropertyDefinition.Builder builder = DurationPropertyDefinition.createBuilder(INSTANCE, "db-checkpointer-wakeup-interval"); 165 builder.setOption(PropertyOption.ADVANCED); 166 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "db-checkpointer-wakeup-interval")); 167 DefaultBehaviorProvider<Long> provider = new DefinedDefaultBehaviorProvider<Long>("15s"); 168 builder.setDefaultBehaviorProvider(provider); 169 builder.setBaseUnit("s"); 170 builder.setUpperLimit("3600"); 171 builder.setLowerLimit("10"); 172 PD_DB_CHECKPOINTER_WAKEUP_INTERVAL = builder.getInstance(); 173 INSTANCE.registerPropertyDefinition(PD_DB_CHECKPOINTER_WAKEUP_INTERVAL); 174 } 175 176 177 178 // Build the "db-directory" property definition. 179 static { 180 StringPropertyDefinition.Builder builder = StringPropertyDefinition.createBuilder(INSTANCE, "db-directory"); 181 builder.setOption(PropertyOption.MANDATORY); 182 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.COMPONENT_RESTART, INSTANCE, "db-directory")); 183 DefaultBehaviorProvider<String> provider = new DefinedDefaultBehaviorProvider<String>("db"); 184 builder.setDefaultBehaviorProvider(provider); 185 PD_DB_DIRECTORY = builder.getInstance(); 186 INSTANCE.registerPropertyDefinition(PD_DB_DIRECTORY); 187 } 188 189 190 191 // Build the "db-directory-permissions" property definition. 192 static { 193 StringPropertyDefinition.Builder builder = StringPropertyDefinition.createBuilder(INSTANCE, "db-directory-permissions"); 194 builder.setOption(PropertyOption.ADVANCED); 195 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.SERVER_RESTART, INSTANCE, "db-directory-permissions")); 196 DefaultBehaviorProvider<String> provider = new DefinedDefaultBehaviorProvider<String>("700"); 197 builder.setDefaultBehaviorProvider(provider); 198 builder.setPattern("^7[0-7][0-7]$", "MODE"); 199 PD_DB_DIRECTORY_PERMISSIONS = builder.getInstance(); 200 INSTANCE.registerPropertyDefinition(PD_DB_DIRECTORY_PERMISSIONS); 201 } 202 203 204 205 // Build the "db-txn-no-sync" property definition. 206 static { 207 BooleanPropertyDefinition.Builder builder = BooleanPropertyDefinition.createBuilder(INSTANCE, "db-txn-no-sync"); 208 builder.setOption(PropertyOption.ADVANCED); 209 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "db-txn-no-sync")); 210 DefaultBehaviorProvider<Boolean> provider = new DefinedDefaultBehaviorProvider<Boolean>("true"); 211 builder.setDefaultBehaviorProvider(provider); 212 PD_DB_TXN_NO_SYNC = builder.getInstance(); 213 INSTANCE.registerPropertyDefinition(PD_DB_TXN_NO_SYNC); 214 } 215 216 217 218 // Build the "disk-full-threshold" property definition. 219 static { 220 SizePropertyDefinition.Builder builder = SizePropertyDefinition.createBuilder(INSTANCE, "disk-full-threshold"); 221 builder.setOption(PropertyOption.ADVANCED); 222 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "disk-full-threshold")); 223 DefaultBehaviorProvider<Long> provider = new DefinedDefaultBehaviorProvider<Long>("100 megabytes"); 224 builder.setDefaultBehaviorProvider(provider); 225 builder.setLowerLimit("0"); 226 PD_DISK_FULL_THRESHOLD = builder.getInstance(); 227 INSTANCE.registerPropertyDefinition(PD_DISK_FULL_THRESHOLD); 228 } 229 230 231 232 // Build the "disk-low-threshold" property definition. 233 static { 234 SizePropertyDefinition.Builder builder = SizePropertyDefinition.createBuilder(INSTANCE, "disk-low-threshold"); 235 builder.setOption(PropertyOption.ADVANCED); 236 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "disk-low-threshold")); 237 DefaultBehaviorProvider<Long> provider = new DefinedDefaultBehaviorProvider<Long>("200 megabytes"); 238 builder.setDefaultBehaviorProvider(provider); 239 builder.setLowerLimit("0"); 240 PD_DISK_LOW_THRESHOLD = builder.getInstance(); 241 INSTANCE.registerPropertyDefinition(PD_DISK_LOW_THRESHOLD); 242 } 243 244 245 246 // Build the "java-class" property definition. 247 static { 248 ClassPropertyDefinition.Builder builder = ClassPropertyDefinition.createBuilder(INSTANCE, "java-class"); 249 builder.setOption(PropertyOption.MANDATORY); 250 builder.setOption(PropertyOption.ADVANCED); 251 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.COMPONENT_RESTART, INSTANCE, "java-class")); 252 DefaultBehaviorProvider<String> provider = new DefinedDefaultBehaviorProvider<String>("org.opends.server.backends.pdb.PDBBackend"); 253 builder.setDefaultBehaviorProvider(provider); 254 builder.addInstanceOf("org.opends.server.api.Backend"); 255 PD_JAVA_CLASS = builder.getInstance(); 256 INSTANCE.registerPropertyDefinition(PD_JAVA_CLASS); 257 } 258 259 260 261 // Register the tags associated with this managed object definition. 262 static { 263 INSTANCE.registerTag(Tag.valueOf("database")); 264 } 265 266 267 268 /** 269 * Get the PDB Backend configuration definition singleton. 270 * 271 * @return Returns the PDB Backend configuration definition 272 * singleton. 273 */ 274 public static PDBBackendCfgDefn getInstance() { 275 return INSTANCE; 276 } 277 278 279 280 /** 281 * Private constructor. 282 */ 283 private PDBBackendCfgDefn() { 284 super("pdb-backend", PluggableBackendCfgDefn.getInstance()); 285 } 286 287 288 289 /** 290 * {@inheritDoc} 291 */ 292 public PDBBackendCfgClient createClientConfiguration( 293 ManagedObject<? extends PDBBackendCfgClient> impl) { 294 return new PDBBackendCfgClientImpl(impl); 295 } 296 297 298 299 /** 300 * {@inheritDoc} 301 */ 302 public PDBBackendCfg createServerConfiguration( 303 ServerManagedObject<? extends PDBBackendCfg> impl) { 304 return new PDBBackendCfgServerImpl(impl); 305 } 306 307 308 309 /** 310 * {@inheritDoc} 311 */ 312 public Class<PDBBackendCfg> getServerConfigurationClass() { 313 return PDBBackendCfg.class; 314 } 315 316 317 318 /** 319 * Get the "backend-id" property definition. 320 * <p> 321 * Specifies a name to identify the associated backend. 322 * <p> 323 * The name must be unique among all backends in the server. The 324 * backend ID may not be altered after the backend is created in the 325 * server. 326 * 327 * @return Returns the "backend-id" property definition. 328 */ 329 public StringPropertyDefinition getBackendIdPropertyDefinition() { 330 return PluggableBackendCfgDefn.getInstance().getBackendIdPropertyDefinition(); 331 } 332 333 334 335 /** 336 * Get the "base-dn" property definition. 337 * <p> 338 * Specifies the base DN(s) for the data that the backend handles. 339 * <p> 340 * A single backend may be responsible for one or more base DNs. 341 * Note that no two backends may have the same base DN although one 342 * backend may have a base DN that is below a base DN provided by 343 * another backend (similar to the use of sub-suffixes in the Sun 344 * Java System Directory Server). If any of the base DNs is 345 * subordinate to a base DN for another backend, then all base DNs 346 * for that backend must be subordinate to that same base DN. 347 * 348 * @return Returns the "base-dn" property definition. 349 */ 350 public DNPropertyDefinition getBaseDNPropertyDefinition() { 351 return PluggableBackendCfgDefn.getInstance().getBaseDNPropertyDefinition(); 352 } 353 354 355 356 /** 357 * Get the "compact-encoding" property definition. 358 * <p> 359 * Indicates whether the backend should use a compact form when 360 * encoding entries by compressing the attribute descriptions and 361 * object class sets. 362 * <p> 363 * Note that this property applies only to the entries themselves 364 * and does not impact the index data. 365 * 366 * @return Returns the "compact-encoding" property definition. 367 */ 368 public BooleanPropertyDefinition getCompactEncodingPropertyDefinition() { 369 return PluggableBackendCfgDefn.getInstance().getCompactEncodingPropertyDefinition(); 370 } 371 372 373 374 /** 375 * Get the "db-cache-percent" property definition. 376 * <p> 377 * Specifies the percentage of JVM memory to allocate to the 378 * database cache. 379 * <p> 380 * Specifies the percentage of memory available to the JVM that 381 * should be used for caching database contents. Note that this is 382 * only used if the value of the db-cache-size property is set to "0 383 * MB". Otherwise, the value of that property is used instead to 384 * control the cache size configuration. 385 * 386 * @return Returns the "db-cache-percent" property definition. 387 */ 388 public IntegerPropertyDefinition getDBCachePercentPropertyDefinition() { 389 return PD_DB_CACHE_PERCENT; 390 } 391 392 393 394 /** 395 * Get the "db-cache-size" property definition. 396 * <p> 397 * The amount of JVM memory to allocate to the database cache. 398 * <p> 399 * Specifies the amount of memory that should be used for caching 400 * database contents. A value of "0 MB" indicates that the 401 * db-cache-percent property should be used instead to specify the 402 * cache size. 403 * 404 * @return Returns the "db-cache-size" property definition. 405 */ 406 public SizePropertyDefinition getDBCacheSizePropertyDefinition() { 407 return PD_DB_CACHE_SIZE; 408 } 409 410 411 412 /** 413 * Get the "db-checkpointer-wakeup-interval" property definition. 414 * <p> 415 * Specifies the maximum length of time that may pass between 416 * checkpoints. 417 * <p> 418 * This setting controls the elapsed time between attempts to write 419 * a checkpoint to the journal. A longer interval allows more updates 420 * to accumulate in buffers before they are required to be written to 421 * disk, but also potentially causes recovery from an abrupt 422 * termination (crash) to take more time. 423 * 424 * @return Returns the "db-checkpointer-wakeup-interval" property definition. 425 */ 426 public DurationPropertyDefinition getDBCheckpointerWakeupIntervalPropertyDefinition() { 427 return PD_DB_CHECKPOINTER_WAKEUP_INTERVAL; 428 } 429 430 431 432 /** 433 * Get the "db-directory" property definition. 434 * <p> 435 * Specifies the path to the filesystem directory that is used to 436 * hold the Persistit database files containing the data for this 437 * backend. 438 * <p> 439 * The path may be either an absolute path or a path relative to the 440 * directory containing the base of the OpenDJ directory server 441 * installation. The path may be any valid directory path in which 442 * the server has appropriate permissions to read and write files and 443 * has sufficient space to hold the database contents. 444 * 445 * @return Returns the "db-directory" property definition. 446 */ 447 public StringPropertyDefinition getDBDirectoryPropertyDefinition() { 448 return PD_DB_DIRECTORY; 449 } 450 451 452 453 /** 454 * Get the "db-directory-permissions" property definition. 455 * <p> 456 * Specifies the permissions that should be applied to the directory 457 * containing the server database files. 458 * <p> 459 * They should be expressed as three-digit octal values, which is 460 * the traditional representation for UNIX file permissions. The 461 * three digits represent the permissions that are available for the 462 * directory's owner, group members, and other users (in that order), 463 * and each digit is the octal representation of the read, write, and 464 * execute bits. Note that this only impacts permissions on the 465 * database directory and not on the files written into that 466 * directory. On UNIX systems, the user's umask controls permissions 467 * given to the database files. 468 * 469 * @return Returns the "db-directory-permissions" property definition. 470 */ 471 public StringPropertyDefinition getDBDirectoryPermissionsPropertyDefinition() { 472 return PD_DB_DIRECTORY_PERMISSIONS; 473 } 474 475 476 477 /** 478 * Get the "db-txn-no-sync" property definition. 479 * <p> 480 * Indicates whether database writes should be primarily written to 481 * an internal buffer but not immediately written to disk. 482 * <p> 483 * Setting the value of this configuration attribute to "true" may 484 * improve write performance but could cause the most recent changes 485 * to be lost if the OpenDJ directory server or the underlying JVM 486 * exits abnormally, or if an OS or hardware failure occurs (a 487 * behavior similar to running with transaction durability disabled 488 * in the Sun Java System Directory Server). 489 * 490 * @return Returns the "db-txn-no-sync" property definition. 491 */ 492 public BooleanPropertyDefinition getDBTxnNoSyncPropertyDefinition() { 493 return PD_DB_TXN_NO_SYNC; 494 } 495 496 497 498 /** 499 * Get the "disk-full-threshold" property definition. 500 * <p> 501 * Full disk threshold to limit database updates 502 * <p> 503 * When the available free space on the disk used by this database 504 * instance falls below the value specified, no updates are permitted 505 * and the server returns an UNWILLING_TO_PERFORM error. Updates are 506 * allowed again as soon as free space rises above the threshold. 507 * 508 * @return Returns the "disk-full-threshold" property definition. 509 */ 510 public SizePropertyDefinition getDiskFullThresholdPropertyDefinition() { 511 return PD_DISK_FULL_THRESHOLD; 512 } 513 514 515 516 /** 517 * Get the "disk-low-threshold" property definition. 518 * <p> 519 * Low disk threshold to limit database updates 520 * <p> 521 * Specifies the "low" free space on the disk. When the available 522 * free space on the disk used by this database instance falls below 523 * the value specified, protocol updates on this database are 524 * permitted only by a user with the BYPASS_LOCKDOWN privilege. 525 * 526 * @return Returns the "disk-low-threshold" property definition. 527 */ 528 public SizePropertyDefinition getDiskLowThresholdPropertyDefinition() { 529 return PD_DISK_LOW_THRESHOLD; 530 } 531 532 533 534 /** 535 * Get the "enabled" property definition. 536 * <p> 537 * Indicates whether the backend is enabled in the server. 538 * <p> 539 * If a backend is not enabled, then its contents are not accessible 540 * when processing operations. 541 * 542 * @return Returns the "enabled" property definition. 543 */ 544 public BooleanPropertyDefinition getEnabledPropertyDefinition() { 545 return PluggableBackendCfgDefn.getInstance().getEnabledPropertyDefinition(); 546 } 547 548 549 550 /** 551 * Get the "entries-compressed" property definition. 552 * <p> 553 * Indicates whether the backend should attempt to compress entries 554 * before storing them in the database. 555 * <p> 556 * Note that this property applies only to the entries themselves 557 * and does not impact the index data. Further, the effectiveness of 558 * the compression is based on the type of data contained in the 559 * entry. 560 * 561 * @return Returns the "entries-compressed" property definition. 562 */ 563 public BooleanPropertyDefinition getEntriesCompressedPropertyDefinition() { 564 return PluggableBackendCfgDefn.getInstance().getEntriesCompressedPropertyDefinition(); 565 } 566 567 568 569 /** 570 * Get the "index-entry-limit" property definition. 571 * <p> 572 * Specifies the maximum number of entries that is allowed to match 573 * a given index key before that particular index key is no longer 574 * maintained. 575 * <p> 576 * This property is analogous to the ALL IDs threshold in the Sun 577 * Java System Directory Server. Note that this is the default limit 578 * for the backend, and it may be overridden on a per-attribute 579 * basis.A value of 0 means there is no limit. 580 * 581 * @return Returns the "index-entry-limit" property definition. 582 */ 583 public IntegerPropertyDefinition getIndexEntryLimitPropertyDefinition() { 584 return PluggableBackendCfgDefn.getInstance().getIndexEntryLimitPropertyDefinition(); 585 } 586 587 588 589 /** 590 * Get the "index-filter-analyzer-enabled" property definition. 591 * <p> 592 * Indicates whether to gather statistical information about the 593 * search filters processed by the directory server while evaluating 594 * the usage of indexes. 595 * <p> 596 * Analyzing indexes requires gathering search filter usage patterns 597 * from user requests, especially for values as specified in the 598 * filters and subsequently looking the status of those values into 599 * the index files. When a search requests is processed, internal or 600 * user generated, a first phase uses indexes to find potential 601 * entries to be returned. Depending on the search filter, if the 602 * index of one of the specified attributes matches too many entries 603 * (exceeds the index entry limit), the search becomes non-indexed. 604 * In any case, all entries thus gathered (or the entire DIT) are 605 * matched against the filter for actually returning the search 606 * result. 607 * 608 * @return Returns the "index-filter-analyzer-enabled" property definition. 609 */ 610 public BooleanPropertyDefinition getIndexFilterAnalyzerEnabledPropertyDefinition() { 611 return PluggableBackendCfgDefn.getInstance().getIndexFilterAnalyzerEnabledPropertyDefinition(); 612 } 613 614 615 616 /** 617 * Get the "index-filter-analyzer-max-filters" property definition. 618 * <p> 619 * The maximum number of search filter statistics to keep. 620 * <p> 621 * When the maximum number of search filter is reached, the least 622 * used one will be deleted. 623 * 624 * @return Returns the "index-filter-analyzer-max-filters" property definition. 625 */ 626 public IntegerPropertyDefinition getIndexFilterAnalyzerMaxFiltersPropertyDefinition() { 627 return PluggableBackendCfgDefn.getInstance().getIndexFilterAnalyzerMaxFiltersPropertyDefinition(); 628 } 629 630 631 632 /** 633 * Get the "java-class" property definition. 634 * <p> 635 * Specifies the fully-qualified name of the Java class that 636 * provides the backend implementation. 637 * 638 * @return Returns the "java-class" property definition. 639 */ 640 public ClassPropertyDefinition getJavaClassPropertyDefinition() { 641 return PD_JAVA_CLASS; 642 } 643 644 645 646 /** 647 * Get the "preload-time-limit" property definition. 648 * <p> 649 * Specifies the length of time that the backend is allowed to spend 650 * "pre-loading" data when it is initialized. 651 * <p> 652 * The pre-load process is used to pre-populate the database cache, 653 * so that it can be more quickly available when the server is 654 * processing requests. A duration of zero means there is no 655 * pre-load. 656 * 657 * @return Returns the "preload-time-limit" property definition. 658 */ 659 public DurationPropertyDefinition getPreloadTimeLimitPropertyDefinition() { 660 return PluggableBackendCfgDefn.getInstance().getPreloadTimeLimitPropertyDefinition(); 661 } 662 663 664 665 /** 666 * Get the "writability-mode" property definition. 667 * <p> 668 * Specifies the behavior that the backend should use when 669 * processing write operations. 670 * 671 * @return Returns the "writability-mode" property definition. 672 */ 673 public EnumPropertyDefinition<WritabilityMode> getWritabilityModePropertyDefinition() { 674 return PluggableBackendCfgDefn.getInstance().getWritabilityModePropertyDefinition(); 675 } 676 677 678 679 /** 680 * Get the "backend-indexes" relation definition. 681 * 682 * @return Returns the "backend-indexes" relation definition. 683 */ 684 public InstantiableRelationDefinition<BackendIndexCfgClient,BackendIndexCfg> getBackendIndexesRelationDefinition() { 685 return PluggableBackendCfgDefn.getInstance().getBackendIndexesRelationDefinition(); 686 } 687 688 689 690 /** 691 * Get the "backend-vlv-indexes" relation definition. 692 * 693 * @return Returns the "backend-vlv-indexes" relation definition. 694 */ 695 public InstantiableRelationDefinition<BackendVLVIndexCfgClient,BackendVLVIndexCfg> getBackendVLVIndexesRelationDefinition() { 696 return PluggableBackendCfgDefn.getInstance().getBackendVLVIndexesRelationDefinition(); 697 } 698 699 700 701 /** 702 * Managed object client implementation. 703 */ 704 private static class PDBBackendCfgClientImpl implements 705 PDBBackendCfgClient { 706 707 // Private implementation. 708 private ManagedObject<? extends PDBBackendCfgClient> impl; 709 710 711 712 // Private constructor. 713 private PDBBackendCfgClientImpl( 714 ManagedObject<? extends PDBBackendCfgClient> impl) { 715 this.impl = impl; 716 } 717 718 719 720 /** 721 * {@inheritDoc} 722 */ 723 public String getBackendId() { 724 return impl.getPropertyValue(INSTANCE.getBackendIdPropertyDefinition()); 725 } 726 727 728 729 /** 730 * {@inheritDoc} 731 */ 732 public void setBackendId(String value) throws PropertyException { 733 impl.setPropertyValue(INSTANCE.getBackendIdPropertyDefinition(), value); 734 } 735 736 737 738 /** 739 * {@inheritDoc} 740 */ 741 public SortedSet<DN> getBaseDN() { 742 return impl.getPropertyValues(INSTANCE.getBaseDNPropertyDefinition()); 743 } 744 745 746 747 /** 748 * {@inheritDoc} 749 */ 750 public void setBaseDN(Collection<DN> values) { 751 impl.setPropertyValues(INSTANCE.getBaseDNPropertyDefinition(), values); 752 } 753 754 755 756 /** 757 * {@inheritDoc} 758 */ 759 public boolean isCompactEncoding() { 760 return impl.getPropertyValue(INSTANCE.getCompactEncodingPropertyDefinition()); 761 } 762 763 764 765 /** 766 * {@inheritDoc} 767 */ 768 public void setCompactEncoding(Boolean value) { 769 impl.setPropertyValue(INSTANCE.getCompactEncodingPropertyDefinition(), value); 770 } 771 772 773 774 /** 775 * {@inheritDoc} 776 */ 777 public int getDBCachePercent() { 778 return impl.getPropertyValue(INSTANCE.getDBCachePercentPropertyDefinition()); 779 } 780 781 782 783 /** 784 * {@inheritDoc} 785 */ 786 public void setDBCachePercent(Integer value) { 787 impl.setPropertyValue(INSTANCE.getDBCachePercentPropertyDefinition(), value); 788 } 789 790 791 792 /** 793 * {@inheritDoc} 794 */ 795 public long getDBCacheSize() { 796 return impl.getPropertyValue(INSTANCE.getDBCacheSizePropertyDefinition()); 797 } 798 799 800 801 /** 802 * {@inheritDoc} 803 */ 804 public void setDBCacheSize(Long value) { 805 impl.setPropertyValue(INSTANCE.getDBCacheSizePropertyDefinition(), value); 806 } 807 808 809 810 /** 811 * {@inheritDoc} 812 */ 813 public long getDBCheckpointerWakeupInterval() { 814 return impl.getPropertyValue(INSTANCE.getDBCheckpointerWakeupIntervalPropertyDefinition()); 815 } 816 817 818 819 /** 820 * {@inheritDoc} 821 */ 822 public void setDBCheckpointerWakeupInterval(Long value) { 823 impl.setPropertyValue(INSTANCE.getDBCheckpointerWakeupIntervalPropertyDefinition(), value); 824 } 825 826 827 828 /** 829 * {@inheritDoc} 830 */ 831 public String getDBDirectory() { 832 return impl.getPropertyValue(INSTANCE.getDBDirectoryPropertyDefinition()); 833 } 834 835 836 837 /** 838 * {@inheritDoc} 839 */ 840 public void setDBDirectory(String value) { 841 impl.setPropertyValue(INSTANCE.getDBDirectoryPropertyDefinition(), value); 842 } 843 844 845 846 /** 847 * {@inheritDoc} 848 */ 849 public String getDBDirectoryPermissions() { 850 return impl.getPropertyValue(INSTANCE.getDBDirectoryPermissionsPropertyDefinition()); 851 } 852 853 854 855 /** 856 * {@inheritDoc} 857 */ 858 public void setDBDirectoryPermissions(String value) { 859 impl.setPropertyValue(INSTANCE.getDBDirectoryPermissionsPropertyDefinition(), value); 860 } 861 862 863 864 /** 865 * {@inheritDoc} 866 */ 867 public boolean isDBTxnNoSync() { 868 return impl.getPropertyValue(INSTANCE.getDBTxnNoSyncPropertyDefinition()); 869 } 870 871 872 873 /** 874 * {@inheritDoc} 875 */ 876 public void setDBTxnNoSync(Boolean value) { 877 impl.setPropertyValue(INSTANCE.getDBTxnNoSyncPropertyDefinition(), value); 878 } 879 880 881 882 /** 883 * {@inheritDoc} 884 */ 885 public long getDiskFullThreshold() { 886 return impl.getPropertyValue(INSTANCE.getDiskFullThresholdPropertyDefinition()); 887 } 888 889 890 891 /** 892 * {@inheritDoc} 893 */ 894 public void setDiskFullThreshold(Long value) { 895 impl.setPropertyValue(INSTANCE.getDiskFullThresholdPropertyDefinition(), value); 896 } 897 898 899 900 /** 901 * {@inheritDoc} 902 */ 903 public long getDiskLowThreshold() { 904 return impl.getPropertyValue(INSTANCE.getDiskLowThresholdPropertyDefinition()); 905 } 906 907 908 909 /** 910 * {@inheritDoc} 911 */ 912 public void setDiskLowThreshold(Long value) { 913 impl.setPropertyValue(INSTANCE.getDiskLowThresholdPropertyDefinition(), value); 914 } 915 916 917 918 /** 919 * {@inheritDoc} 920 */ 921 public Boolean isEnabled() { 922 return impl.getPropertyValue(INSTANCE.getEnabledPropertyDefinition()); 923 } 924 925 926 927 /** 928 * {@inheritDoc} 929 */ 930 public void setEnabled(boolean value) { 931 impl.setPropertyValue(INSTANCE.getEnabledPropertyDefinition(), value); 932 } 933 934 935 936 /** 937 * {@inheritDoc} 938 */ 939 public boolean isEntriesCompressed() { 940 return impl.getPropertyValue(INSTANCE.getEntriesCompressedPropertyDefinition()); 941 } 942 943 944 945 /** 946 * {@inheritDoc} 947 */ 948 public void setEntriesCompressed(Boolean value) { 949 impl.setPropertyValue(INSTANCE.getEntriesCompressedPropertyDefinition(), value); 950 } 951 952 953 954 /** 955 * {@inheritDoc} 956 */ 957 public int getIndexEntryLimit() { 958 return impl.getPropertyValue(INSTANCE.getIndexEntryLimitPropertyDefinition()); 959 } 960 961 962 963 /** 964 * {@inheritDoc} 965 */ 966 public void setIndexEntryLimit(Integer value) { 967 impl.setPropertyValue(INSTANCE.getIndexEntryLimitPropertyDefinition(), value); 968 } 969 970 971 972 /** 973 * {@inheritDoc} 974 */ 975 public boolean isIndexFilterAnalyzerEnabled() { 976 return impl.getPropertyValue(INSTANCE.getIndexFilterAnalyzerEnabledPropertyDefinition()); 977 } 978 979 980 981 /** 982 * {@inheritDoc} 983 */ 984 public void setIndexFilterAnalyzerEnabled(Boolean value) { 985 impl.setPropertyValue(INSTANCE.getIndexFilterAnalyzerEnabledPropertyDefinition(), value); 986 } 987 988 989 990 /** 991 * {@inheritDoc} 992 */ 993 public int getIndexFilterAnalyzerMaxFilters() { 994 return impl.getPropertyValue(INSTANCE.getIndexFilterAnalyzerMaxFiltersPropertyDefinition()); 995 } 996 997 998 999 /** 1000 * {@inheritDoc} 1001 */ 1002 public void setIndexFilterAnalyzerMaxFilters(Integer value) { 1003 impl.setPropertyValue(INSTANCE.getIndexFilterAnalyzerMaxFiltersPropertyDefinition(), value); 1004 } 1005 1006 1007 1008 /** 1009 * {@inheritDoc} 1010 */ 1011 public String getJavaClass() { 1012 return impl.getPropertyValue(INSTANCE.getJavaClassPropertyDefinition()); 1013 } 1014 1015 1016 1017 /** 1018 * {@inheritDoc} 1019 */ 1020 public void setJavaClass(String value) { 1021 impl.setPropertyValue(INSTANCE.getJavaClassPropertyDefinition(), value); 1022 } 1023 1024 1025 1026 /** 1027 * {@inheritDoc} 1028 */ 1029 public long getPreloadTimeLimit() { 1030 return impl.getPropertyValue(INSTANCE.getPreloadTimeLimitPropertyDefinition()); 1031 } 1032 1033 1034 1035 /** 1036 * {@inheritDoc} 1037 */ 1038 public void setPreloadTimeLimit(Long value) { 1039 impl.setPropertyValue(INSTANCE.getPreloadTimeLimitPropertyDefinition(), value); 1040 } 1041 1042 1043 1044 /** 1045 * {@inheritDoc} 1046 */ 1047 public WritabilityMode getWritabilityMode() { 1048 return impl.getPropertyValue(INSTANCE.getWritabilityModePropertyDefinition()); 1049 } 1050 1051 1052 1053 /** 1054 * {@inheritDoc} 1055 */ 1056 public void setWritabilityMode(WritabilityMode value) { 1057 impl.setPropertyValue(INSTANCE.getWritabilityModePropertyDefinition(), value); 1058 } 1059 1060 1061 1062 /** 1063 * {@inheritDoc} 1064 */ 1065 public String[] listBackendIndexes() throws ConcurrentModificationException, 1066 LdapException { 1067 return impl.listChildren(INSTANCE.getBackendIndexesRelationDefinition()); 1068 } 1069 1070 1071 1072 /** 1073 * {@inheritDoc} 1074 */ 1075 public BackendIndexCfgClient getBackendIndex(String name) 1076 throws DefinitionDecodingException, ManagedObjectDecodingException, 1077 ManagedObjectNotFoundException, ConcurrentModificationException, 1078 LdapException { 1079 return impl.getChild(INSTANCE.getBackendIndexesRelationDefinition(), name).getConfiguration(); 1080 } 1081 1082 1083 1084 /** 1085 * {@inheritDoc} 1086 */ 1087 public <M extends BackendIndexCfgClient> M createBackendIndex( 1088 ManagedObjectDefinition<M, ? extends BackendIndexCfg> d, String name, Collection<PropertyException> exceptions) throws IllegalManagedObjectNameException { 1089 return impl.createChild(INSTANCE.getBackendIndexesRelationDefinition(), d, name, exceptions).getConfiguration(); 1090 } 1091 1092 1093 1094 /** 1095 * {@inheritDoc} 1096 */ 1097 public void removeBackendIndex(String name) 1098 throws ManagedObjectNotFoundException, ConcurrentModificationException, 1099 OperationRejectedException, LdapException { 1100 impl.removeChild(INSTANCE.getBackendIndexesRelationDefinition(), name); 1101 } 1102 1103 1104 1105 /** 1106 * {@inheritDoc} 1107 */ 1108 public String[] listBackendVLVIndexes() throws ConcurrentModificationException, 1109 LdapException { 1110 return impl.listChildren(INSTANCE.getBackendVLVIndexesRelationDefinition()); 1111 } 1112 1113 1114 1115 /** 1116 * {@inheritDoc} 1117 */ 1118 public BackendVLVIndexCfgClient getBackendVLVIndex(String name) 1119 throws DefinitionDecodingException, ManagedObjectDecodingException, 1120 ManagedObjectNotFoundException, ConcurrentModificationException, 1121 LdapException { 1122 return impl.getChild(INSTANCE.getBackendVLVIndexesRelationDefinition(), name).getConfiguration(); 1123 } 1124 1125 1126 1127 /** 1128 * {@inheritDoc} 1129 */ 1130 public <M extends BackendVLVIndexCfgClient> M createBackendVLVIndex( 1131 ManagedObjectDefinition<M, ? extends BackendVLVIndexCfg> d, String name, Collection<PropertyException> exceptions) throws IllegalManagedObjectNameException { 1132 return impl.createChild(INSTANCE.getBackendVLVIndexesRelationDefinition(), d, name, exceptions).getConfiguration(); 1133 } 1134 1135 1136 1137 /** 1138 * {@inheritDoc} 1139 */ 1140 public void removeBackendVLVIndex(String name) 1141 throws ManagedObjectNotFoundException, ConcurrentModificationException, 1142 OperationRejectedException, LdapException { 1143 impl.removeChild(INSTANCE.getBackendVLVIndexesRelationDefinition(), name); 1144 } 1145 1146 1147 1148 /** 1149 * {@inheritDoc} 1150 */ 1151 public ManagedObjectDefinition<? extends PDBBackendCfgClient, ? extends PDBBackendCfg> definition() { 1152 return INSTANCE; 1153 } 1154 1155 1156 1157 /** 1158 * {@inheritDoc} 1159 */ 1160 public PropertyProvider properties() { 1161 return impl; 1162 } 1163 1164 1165 1166 /** 1167 * {@inheritDoc} 1168 */ 1169 public void commit() throws ManagedObjectAlreadyExistsException, 1170 MissingMandatoryPropertiesException, ConcurrentModificationException, 1171 OperationRejectedException, LdapException { 1172 impl.commit(); 1173 } 1174 1175 } 1176 1177 1178 1179 /** 1180 * Managed object server implementation. 1181 */ 1182 private static class PDBBackendCfgServerImpl implements 1183 PDBBackendCfg { 1184 1185 // Private implementation. 1186 private ServerManagedObject<? extends PDBBackendCfg> impl; 1187 1188 // The value of the "backend-id" property. 1189 private final String pBackendId; 1190 1191 // The value of the "base-dn" property. 1192 private final SortedSet<DN> pBaseDN; 1193 1194 // The value of the "compact-encoding" property. 1195 private final boolean pCompactEncoding; 1196 1197 // The value of the "db-cache-percent" property. 1198 private final int pDBCachePercent; 1199 1200 // The value of the "db-cache-size" property. 1201 private final long pDBCacheSize; 1202 1203 // The value of the "db-checkpointer-wakeup-interval" property. 1204 private final long pDBCheckpointerWakeupInterval; 1205 1206 // The value of the "db-directory" property. 1207 private final String pDBDirectory; 1208 1209 // The value of the "db-directory-permissions" property. 1210 private final String pDBDirectoryPermissions; 1211 1212 // The value of the "db-txn-no-sync" property. 1213 private final boolean pDBTxnNoSync; 1214 1215 // The value of the "disk-full-threshold" property. 1216 private final long pDiskFullThreshold; 1217 1218 // The value of the "disk-low-threshold" property. 1219 private final long pDiskLowThreshold; 1220 1221 // The value of the "enabled" property. 1222 private final boolean pEnabled; 1223 1224 // The value of the "entries-compressed" property. 1225 private final boolean pEntriesCompressed; 1226 1227 // The value of the "index-entry-limit" property. 1228 private final int pIndexEntryLimit; 1229 1230 // The value of the "index-filter-analyzer-enabled" property. 1231 private final boolean pIndexFilterAnalyzerEnabled; 1232 1233 // The value of the "index-filter-analyzer-max-filters" property. 1234 private final int pIndexFilterAnalyzerMaxFilters; 1235 1236 // The value of the "java-class" property. 1237 private final String pJavaClass; 1238 1239 // The value of the "preload-time-limit" property. 1240 private final long pPreloadTimeLimit; 1241 1242 // The value of the "writability-mode" property. 1243 private final WritabilityMode pWritabilityMode; 1244 1245 1246 1247 // Private constructor. 1248 private PDBBackendCfgServerImpl(ServerManagedObject<? extends PDBBackendCfg> impl) { 1249 this.impl = impl; 1250 this.pBackendId = impl.getPropertyValue(INSTANCE.getBackendIdPropertyDefinition()); 1251 this.pBaseDN = impl.getPropertyValues(INSTANCE.getBaseDNPropertyDefinition()); 1252 this.pCompactEncoding = impl.getPropertyValue(INSTANCE.getCompactEncodingPropertyDefinition()); 1253 this.pDBCachePercent = impl.getPropertyValue(INSTANCE.getDBCachePercentPropertyDefinition()); 1254 this.pDBCacheSize = impl.getPropertyValue(INSTANCE.getDBCacheSizePropertyDefinition()); 1255 this.pDBCheckpointerWakeupInterval = impl.getPropertyValue(INSTANCE.getDBCheckpointerWakeupIntervalPropertyDefinition()); 1256 this.pDBDirectory = impl.getPropertyValue(INSTANCE.getDBDirectoryPropertyDefinition()); 1257 this.pDBDirectoryPermissions = impl.getPropertyValue(INSTANCE.getDBDirectoryPermissionsPropertyDefinition()); 1258 this.pDBTxnNoSync = impl.getPropertyValue(INSTANCE.getDBTxnNoSyncPropertyDefinition()); 1259 this.pDiskFullThreshold = impl.getPropertyValue(INSTANCE.getDiskFullThresholdPropertyDefinition()); 1260 this.pDiskLowThreshold = impl.getPropertyValue(INSTANCE.getDiskLowThresholdPropertyDefinition()); 1261 this.pEnabled = impl.getPropertyValue(INSTANCE.getEnabledPropertyDefinition()); 1262 this.pEntriesCompressed = impl.getPropertyValue(INSTANCE.getEntriesCompressedPropertyDefinition()); 1263 this.pIndexEntryLimit = impl.getPropertyValue(INSTANCE.getIndexEntryLimitPropertyDefinition()); 1264 this.pIndexFilterAnalyzerEnabled = impl.getPropertyValue(INSTANCE.getIndexFilterAnalyzerEnabledPropertyDefinition()); 1265 this.pIndexFilterAnalyzerMaxFilters = impl.getPropertyValue(INSTANCE.getIndexFilterAnalyzerMaxFiltersPropertyDefinition()); 1266 this.pJavaClass = impl.getPropertyValue(INSTANCE.getJavaClassPropertyDefinition()); 1267 this.pPreloadTimeLimit = impl.getPropertyValue(INSTANCE.getPreloadTimeLimitPropertyDefinition()); 1268 this.pWritabilityMode = impl.getPropertyValue(INSTANCE.getWritabilityModePropertyDefinition()); 1269 } 1270 1271 1272 1273 /** 1274 * {@inheritDoc} 1275 */ 1276 public void addPDBChangeListener( 1277 ConfigurationChangeListener<PDBBackendCfg> listener) { 1278 impl.registerChangeListener(listener); 1279 } 1280 1281 1282 1283 /** 1284 * {@inheritDoc} 1285 */ 1286 public void removePDBChangeListener( 1287 ConfigurationChangeListener<PDBBackendCfg> listener) { 1288 impl.deregisterChangeListener(listener); 1289 } 1290 /** 1291 * {@inheritDoc} 1292 */ 1293 public void addPluggableChangeListener( 1294 ConfigurationChangeListener<PluggableBackendCfg> listener) { 1295 impl.registerChangeListener(listener); 1296 } 1297 1298 1299 1300 /** 1301 * {@inheritDoc} 1302 */ 1303 public void removePluggableChangeListener( 1304 ConfigurationChangeListener<PluggableBackendCfg> listener) { 1305 impl.deregisterChangeListener(listener); 1306 } 1307 /** 1308 * {@inheritDoc} 1309 */ 1310 public void addChangeListener( 1311 ConfigurationChangeListener<BackendCfg> listener) { 1312 impl.registerChangeListener(listener); 1313 } 1314 1315 1316 1317 /** 1318 * {@inheritDoc} 1319 */ 1320 public void removeChangeListener( 1321 ConfigurationChangeListener<BackendCfg> listener) { 1322 impl.deregisterChangeListener(listener); 1323 } 1324 1325 1326 1327 /** 1328 * {@inheritDoc} 1329 */ 1330 public String getBackendId() { 1331 return pBackendId; 1332 } 1333 1334 1335 1336 /** 1337 * {@inheritDoc} 1338 */ 1339 public SortedSet<DN> getBaseDN() { 1340 return pBaseDN; 1341 } 1342 1343 1344 1345 /** 1346 * {@inheritDoc} 1347 */ 1348 public boolean isCompactEncoding() { 1349 return pCompactEncoding; 1350 } 1351 1352 1353 1354 /** 1355 * {@inheritDoc} 1356 */ 1357 public int getDBCachePercent() { 1358 return pDBCachePercent; 1359 } 1360 1361 1362 1363 /** 1364 * {@inheritDoc} 1365 */ 1366 public long getDBCacheSize() { 1367 return pDBCacheSize; 1368 } 1369 1370 1371 1372 /** 1373 * {@inheritDoc} 1374 */ 1375 public long getDBCheckpointerWakeupInterval() { 1376 return pDBCheckpointerWakeupInterval; 1377 } 1378 1379 1380 1381 /** 1382 * {@inheritDoc} 1383 */ 1384 public String getDBDirectory() { 1385 return pDBDirectory; 1386 } 1387 1388 1389 1390 /** 1391 * {@inheritDoc} 1392 */ 1393 public String getDBDirectoryPermissions() { 1394 return pDBDirectoryPermissions; 1395 } 1396 1397 1398 1399 /** 1400 * {@inheritDoc} 1401 */ 1402 public boolean isDBTxnNoSync() { 1403 return pDBTxnNoSync; 1404 } 1405 1406 1407 1408 /** 1409 * {@inheritDoc} 1410 */ 1411 public long getDiskFullThreshold() { 1412 return pDiskFullThreshold; 1413 } 1414 1415 1416 1417 /** 1418 * {@inheritDoc} 1419 */ 1420 public long getDiskLowThreshold() { 1421 return pDiskLowThreshold; 1422 } 1423 1424 1425 1426 /** 1427 * {@inheritDoc} 1428 */ 1429 public boolean isEnabled() { 1430 return pEnabled; 1431 } 1432 1433 1434 1435 /** 1436 * {@inheritDoc} 1437 */ 1438 public boolean isEntriesCompressed() { 1439 return pEntriesCompressed; 1440 } 1441 1442 1443 1444 /** 1445 * {@inheritDoc} 1446 */ 1447 public int getIndexEntryLimit() { 1448 return pIndexEntryLimit; 1449 } 1450 1451 1452 1453 /** 1454 * {@inheritDoc} 1455 */ 1456 public boolean isIndexFilterAnalyzerEnabled() { 1457 return pIndexFilterAnalyzerEnabled; 1458 } 1459 1460 1461 1462 /** 1463 * {@inheritDoc} 1464 */ 1465 public int getIndexFilterAnalyzerMaxFilters() { 1466 return pIndexFilterAnalyzerMaxFilters; 1467 } 1468 1469 1470 1471 /** 1472 * {@inheritDoc} 1473 */ 1474 public String getJavaClass() { 1475 return pJavaClass; 1476 } 1477 1478 1479 1480 /** 1481 * {@inheritDoc} 1482 */ 1483 public long getPreloadTimeLimit() { 1484 return pPreloadTimeLimit; 1485 } 1486 1487 1488 1489 /** 1490 * {@inheritDoc} 1491 */ 1492 public WritabilityMode getWritabilityMode() { 1493 return pWritabilityMode; 1494 } 1495 1496 1497 1498 /** 1499 * {@inheritDoc} 1500 */ 1501 public String[] listBackendIndexes() { 1502 return impl.listChildren(INSTANCE.getBackendIndexesRelationDefinition()); 1503 } 1504 1505 1506 1507 /** 1508 * {@inheritDoc} 1509 */ 1510 public BackendIndexCfg getBackendIndex(String name) throws ConfigException { 1511 return impl.getChild(INSTANCE.getBackendIndexesRelationDefinition(), name).getConfiguration(); 1512 } 1513 1514 1515 1516 /** 1517 * {@inheritDoc} 1518 */ 1519 public void addBackendIndexAddListener( 1520 ConfigurationAddListener<BackendIndexCfg> listener) throws ConfigException { 1521 impl.registerAddListener(INSTANCE.getBackendIndexesRelationDefinition(), listener); 1522 } 1523 1524 1525 1526 /** 1527 * {@inheritDoc} 1528 */ 1529 public void removeBackendIndexAddListener( 1530 ConfigurationAddListener<BackendIndexCfg> listener) { 1531 impl.deregisterAddListener(INSTANCE.getBackendIndexesRelationDefinition(), listener); 1532 } 1533 1534 1535 1536 /** 1537 * {@inheritDoc} 1538 */ 1539 public void addBackendIndexDeleteListener( 1540 ConfigurationDeleteListener<BackendIndexCfg> listener) throws ConfigException { 1541 impl.registerDeleteListener(INSTANCE.getBackendIndexesRelationDefinition(), listener); 1542 } 1543 1544 1545 1546 /** 1547 * {@inheritDoc} 1548 */ 1549 public void removeBackendIndexDeleteListener( 1550 ConfigurationDeleteListener<BackendIndexCfg> listener) { 1551 impl.deregisterDeleteListener(INSTANCE.getBackendIndexesRelationDefinition(), listener); 1552 } 1553 1554 1555 1556 /** 1557 * {@inheritDoc} 1558 */ 1559 public String[] listBackendVLVIndexes() { 1560 return impl.listChildren(INSTANCE.getBackendVLVIndexesRelationDefinition()); 1561 } 1562 1563 1564 1565 /** 1566 * {@inheritDoc} 1567 */ 1568 public BackendVLVIndexCfg getBackendVLVIndex(String name) throws ConfigException { 1569 return impl.getChild(INSTANCE.getBackendVLVIndexesRelationDefinition(), name).getConfiguration(); 1570 } 1571 1572 1573 1574 /** 1575 * {@inheritDoc} 1576 */ 1577 public void addBackendVLVIndexAddListener( 1578 ConfigurationAddListener<BackendVLVIndexCfg> listener) throws ConfigException { 1579 impl.registerAddListener(INSTANCE.getBackendVLVIndexesRelationDefinition(), listener); 1580 } 1581 1582 1583 1584 /** 1585 * {@inheritDoc} 1586 */ 1587 public void removeBackendVLVIndexAddListener( 1588 ConfigurationAddListener<BackendVLVIndexCfg> listener) { 1589 impl.deregisterAddListener(INSTANCE.getBackendVLVIndexesRelationDefinition(), listener); 1590 } 1591 1592 1593 1594 /** 1595 * {@inheritDoc} 1596 */ 1597 public void addBackendVLVIndexDeleteListener( 1598 ConfigurationDeleteListener<BackendVLVIndexCfg> listener) throws ConfigException { 1599 impl.registerDeleteListener(INSTANCE.getBackendVLVIndexesRelationDefinition(), listener); 1600 } 1601 1602 1603 1604 /** 1605 * {@inheritDoc} 1606 */ 1607 public void removeBackendVLVIndexDeleteListener( 1608 ConfigurationDeleteListener<BackendVLVIndexCfg> listener) { 1609 impl.deregisterDeleteListener(INSTANCE.getBackendVLVIndexesRelationDefinition(), listener); 1610 } 1611 1612 1613 1614 /** 1615 * {@inheritDoc} 1616 */ 1617 public Class<? extends PDBBackendCfg> configurationClass() { 1618 return PDBBackendCfg.class; 1619 } 1620 1621 1622 1623 /** 1624 * {@inheritDoc} 1625 */ 1626 public DN dn() { 1627 return impl.getDN(); 1628 } 1629 1630 } 1631}