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 org.forgerock.opendj.config.AbstractManagedObjectDefinition; 021import org.forgerock.opendj.config.AdministratorAction; 022import org.forgerock.opendj.config.AliasDefaultBehaviorProvider; 023import org.forgerock.opendj.config.BooleanPropertyDefinition; 024import org.forgerock.opendj.config.ClassPropertyDefinition; 025import org.forgerock.opendj.config.DefaultBehaviorProvider; 026import org.forgerock.opendj.config.DefaultManagedObject; 027import org.forgerock.opendj.config.DefinedDefaultBehaviorProvider; 028import org.forgerock.opendj.config.DNPropertyDefinition; 029import org.forgerock.opendj.config.DurationPropertyDefinition; 030import org.forgerock.opendj.config.EnumPropertyDefinition; 031import org.forgerock.opendj.config.InstantiableRelationDefinition; 032import org.forgerock.opendj.config.IntegerPropertyDefinition; 033import org.forgerock.opendj.config.PropertyOption; 034import org.forgerock.opendj.config.SizePropertyDefinition; 035import org.forgerock.opendj.config.StringPropertyDefinition; 036import org.forgerock.opendj.config.Tag; 037import org.forgerock.opendj.ldap.DN; 038import org.forgerock.opendj.server.config.client.BackendIndexCfgClient; 039import org.forgerock.opendj.server.config.client.BackendVLVIndexCfgClient; 040import org.forgerock.opendj.server.config.client.PluggableBackendCfgClient; 041import org.forgerock.opendj.server.config.meta.BackendCfgDefn.WritabilityMode; 042import org.forgerock.opendj.server.config.meta.BackendIndexCfgDefn; 043import org.forgerock.opendj.server.config.server.BackendIndexCfg; 044import org.forgerock.opendj.server.config.server.BackendVLVIndexCfg; 045import org.forgerock.opendj.server.config.server.PluggableBackendCfg; 046 047 048 049/** 050 * An interface for querying the Pluggable Backend managed object 051 * definition meta information. 052 * <p> 053 * A Pluggable Backend stores application data in a pluggable 054 * database. 055 */ 056public final class PluggableBackendCfgDefn extends AbstractManagedObjectDefinition<PluggableBackendCfgClient, PluggableBackendCfg> { 057 058 /** The singleton configuration definition instance. */ 059 private static final PluggableBackendCfgDefn INSTANCE = new PluggableBackendCfgDefn(); 060 061 062 063 /** The "cipher-key-length" property definition. */ 064 private static final IntegerPropertyDefinition PD_CIPHER_KEY_LENGTH; 065 066 067 068 /** The "cipher-transformation" property definition. */ 069 private static final StringPropertyDefinition PD_CIPHER_TRANSFORMATION; 070 071 072 073 /** The "compact-encoding" property definition. */ 074 private static final BooleanPropertyDefinition PD_COMPACT_ENCODING; 075 076 077 078 /** The "confidentiality-enabled" property definition. */ 079 private static final BooleanPropertyDefinition PD_CONFIDENTIALITY_ENABLED; 080 081 082 083 /** The "entries-compressed" property definition. */ 084 private static final BooleanPropertyDefinition PD_ENTRIES_COMPRESSED; 085 086 087 088 /** The "import-offheap-memory-size" property definition. */ 089 private static final SizePropertyDefinition PD_IMPORT_OFFHEAP_MEMORY_SIZE; 090 091 092 093 /** The "index-entry-limit" property definition. */ 094 private static final IntegerPropertyDefinition PD_INDEX_ENTRY_LIMIT; 095 096 097 098 /** The "index-filter-analyzer-enabled" property definition. */ 099 private static final BooleanPropertyDefinition PD_INDEX_FILTER_ANALYZER_ENABLED; 100 101 102 103 /** The "index-filter-analyzer-max-filters" property definition. */ 104 private static final IntegerPropertyDefinition PD_INDEX_FILTER_ANALYZER_MAX_FILTERS; 105 106 107 108 /** The "preload-time-limit" property definition. */ 109 private static final DurationPropertyDefinition PD_PRELOAD_TIME_LIMIT; 110 111 112 113 /** The "writability-mode" property definition. */ 114 private static final EnumPropertyDefinition<WritabilityMode> PD_WRITABILITY_MODE; 115 116 117 118 /** The "backend-indexes" relation definition. */ 119 private static final InstantiableRelationDefinition<BackendIndexCfgClient, BackendIndexCfg> RD_BACKEND_INDEXES; 120 121 122 123 /** The "backend-vlv-indexes" relation definition. */ 124 private static final InstantiableRelationDefinition<BackendVLVIndexCfgClient, BackendVLVIndexCfg> RD_BACKEND_VLV_INDEXES; 125 126 127 128 /** Build the "cipher-key-length" property definition. */ 129 static { 130 IntegerPropertyDefinition.Builder builder = IntegerPropertyDefinition.createBuilder(INSTANCE, "cipher-key-length"); 131 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "cipher-key-length")); 132 DefaultBehaviorProvider<Integer> provider = new DefinedDefaultBehaviorProvider<Integer>("128"); 133 builder.setDefaultBehaviorProvider(provider); 134 PD_CIPHER_KEY_LENGTH = builder.getInstance(); 135 INSTANCE.registerPropertyDefinition(PD_CIPHER_KEY_LENGTH); 136 } 137 138 139 140 /** Build the "cipher-transformation" property definition. */ 141 static { 142 StringPropertyDefinition.Builder builder = StringPropertyDefinition.createBuilder(INSTANCE, "cipher-transformation"); 143 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "cipher-transformation")); 144 DefaultBehaviorProvider<String> provider = new DefinedDefaultBehaviorProvider<String>("AES/CBC/PKCS5Padding"); 145 builder.setDefaultBehaviorProvider(provider); 146 PD_CIPHER_TRANSFORMATION = builder.getInstance(); 147 INSTANCE.registerPropertyDefinition(PD_CIPHER_TRANSFORMATION); 148 } 149 150 151 152 /** Build the "compact-encoding" property definition. */ 153 static { 154 BooleanPropertyDefinition.Builder builder = BooleanPropertyDefinition.createBuilder(INSTANCE, "compact-encoding"); 155 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "compact-encoding")); 156 DefaultBehaviorProvider<Boolean> provider = new DefinedDefaultBehaviorProvider<Boolean>("true"); 157 builder.setDefaultBehaviorProvider(provider); 158 PD_COMPACT_ENCODING = builder.getInstance(); 159 INSTANCE.registerPropertyDefinition(PD_COMPACT_ENCODING); 160 } 161 162 163 164 /** Build the "confidentiality-enabled" property definition. */ 165 static { 166 BooleanPropertyDefinition.Builder builder = BooleanPropertyDefinition.createBuilder(INSTANCE, "confidentiality-enabled"); 167 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "confidentiality-enabled")); 168 DefaultBehaviorProvider<Boolean> provider = new DefinedDefaultBehaviorProvider<Boolean>("false"); 169 builder.setDefaultBehaviorProvider(provider); 170 PD_CONFIDENTIALITY_ENABLED = builder.getInstance(); 171 INSTANCE.registerPropertyDefinition(PD_CONFIDENTIALITY_ENABLED); 172 } 173 174 175 176 /** Build the "entries-compressed" property definition. */ 177 static { 178 BooleanPropertyDefinition.Builder builder = BooleanPropertyDefinition.createBuilder(INSTANCE, "entries-compressed"); 179 builder.setOption(PropertyOption.ADVANCED); 180 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "entries-compressed")); 181 DefaultBehaviorProvider<Boolean> provider = new DefinedDefaultBehaviorProvider<Boolean>("false"); 182 builder.setDefaultBehaviorProvider(provider); 183 PD_ENTRIES_COMPRESSED = builder.getInstance(); 184 INSTANCE.registerPropertyDefinition(PD_ENTRIES_COMPRESSED); 185 } 186 187 188 189 /** Build the "import-offheap-memory-size" property definition. */ 190 static { 191 SizePropertyDefinition.Builder builder = SizePropertyDefinition.createBuilder(INSTANCE, "import-offheap-memory-size"); 192 builder.setOption(PropertyOption.ADVANCED); 193 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "import-offheap-memory-size")); 194 builder.setDefaultBehaviorProvider(new AliasDefaultBehaviorProvider<Long>(INSTANCE, "import-offheap-memory-size")); 195 builder.setLowerLimit("0 MB"); 196 PD_IMPORT_OFFHEAP_MEMORY_SIZE = builder.getInstance(); 197 INSTANCE.registerPropertyDefinition(PD_IMPORT_OFFHEAP_MEMORY_SIZE); 198 } 199 200 201 202 /** Build the "index-entry-limit" property definition. */ 203 static { 204 IntegerPropertyDefinition.Builder builder = IntegerPropertyDefinition.createBuilder(INSTANCE, "index-entry-limit"); 205 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "index-entry-limit")); 206 DefaultBehaviorProvider<Integer> provider = new DefinedDefaultBehaviorProvider<Integer>("4000"); 207 builder.setDefaultBehaviorProvider(provider); 208 builder.setUpperLimit(2147483647); 209 builder.setLowerLimit(0); 210 PD_INDEX_ENTRY_LIMIT = builder.getInstance(); 211 INSTANCE.registerPropertyDefinition(PD_INDEX_ENTRY_LIMIT); 212 } 213 214 215 216 /** Build the "index-filter-analyzer-enabled" property definition. */ 217 static { 218 BooleanPropertyDefinition.Builder builder = BooleanPropertyDefinition.createBuilder(INSTANCE, "index-filter-analyzer-enabled"); 219 builder.setOption(PropertyOption.ADVANCED); 220 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "index-filter-analyzer-enabled")); 221 DefaultBehaviorProvider<Boolean> provider = new DefinedDefaultBehaviorProvider<Boolean>("false"); 222 builder.setDefaultBehaviorProvider(provider); 223 PD_INDEX_FILTER_ANALYZER_ENABLED = builder.getInstance(); 224 INSTANCE.registerPropertyDefinition(PD_INDEX_FILTER_ANALYZER_ENABLED); 225 } 226 227 228 229 /** Build the "index-filter-analyzer-max-filters" property definition. */ 230 static { 231 IntegerPropertyDefinition.Builder builder = IntegerPropertyDefinition.createBuilder(INSTANCE, "index-filter-analyzer-max-filters"); 232 builder.setOption(PropertyOption.ADVANCED); 233 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "index-filter-analyzer-max-filters")); 234 DefaultBehaviorProvider<Integer> provider = new DefinedDefaultBehaviorProvider<Integer>("25"); 235 builder.setDefaultBehaviorProvider(provider); 236 builder.setLowerLimit(1); 237 PD_INDEX_FILTER_ANALYZER_MAX_FILTERS = builder.getInstance(); 238 INSTANCE.registerPropertyDefinition(PD_INDEX_FILTER_ANALYZER_MAX_FILTERS); 239 } 240 241 242 243 /** Build the "preload-time-limit" property definition. */ 244 static { 245 DurationPropertyDefinition.Builder builder = DurationPropertyDefinition.createBuilder(INSTANCE, "preload-time-limit"); 246 builder.setOption(PropertyOption.ADVANCED); 247 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "preload-time-limit")); 248 DefaultBehaviorProvider<Long> provider = new DefinedDefaultBehaviorProvider<Long>("0s"); 249 builder.setDefaultBehaviorProvider(provider); 250 builder.setBaseUnit("ms"); 251 builder.setUpperLimit("2147483647"); 252 builder.setLowerLimit("0"); 253 PD_PRELOAD_TIME_LIMIT = builder.getInstance(); 254 INSTANCE.registerPropertyDefinition(PD_PRELOAD_TIME_LIMIT); 255 } 256 257 258 259 /** Build the "writability-mode" property definition. */ 260 static { 261 EnumPropertyDefinition.Builder<WritabilityMode> builder = EnumPropertyDefinition.createBuilder(INSTANCE, "writability-mode"); 262 builder.setOption(PropertyOption.MANDATORY); 263 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "writability-mode")); 264 DefaultBehaviorProvider<WritabilityMode> provider = new DefinedDefaultBehaviorProvider<WritabilityMode>("enabled"); 265 builder.setDefaultBehaviorProvider(provider); 266 builder.setEnumClass(WritabilityMode.class); 267 PD_WRITABILITY_MODE = builder.getInstance(); 268 INSTANCE.registerPropertyDefinition(PD_WRITABILITY_MODE); 269 } 270 271 272 273 // Build the "backend-indexes" relation definition. 274 static { 275 InstantiableRelationDefinition.Builder<BackendIndexCfgClient, BackendIndexCfg> builder = 276 new InstantiableRelationDefinition.Builder<BackendIndexCfgClient, BackendIndexCfg>(INSTANCE, "backend-index", "backend-indexes", BackendIndexCfgDefn.getInstance()); 277 builder.setNamingProperty(BackendIndexCfgDefn.getInstance().getAttributePropertyDefinition()); 278 { 279 DefaultManagedObject.Builder<BackendIndexCfgClient, BackendIndexCfg> dmoBuilder = new DefaultManagedObject.Builder<BackendIndexCfgClient, BackendIndexCfg>(BackendIndexCfgDefn.getInstance()); 280 dmoBuilder.setPropertyValues("index-type", "presence"); 281 dmoBuilder.setPropertyValues("attribute", "aci"); 282 builder.setDefaultManagedObject("aci", dmoBuilder.getInstance()); 283 } 284 { 285 DefaultManagedObject.Builder<BackendIndexCfgClient, BackendIndexCfg> dmoBuilder = new DefaultManagedObject.Builder<BackendIndexCfgClient, BackendIndexCfg>(BackendIndexCfgDefn.getInstance()); 286 dmoBuilder.setPropertyValues("index-type", "equality"); 287 dmoBuilder.setPropertyValues("attribute", "entryUUID"); 288 builder.setDefaultManagedObject("entryUUID", dmoBuilder.getInstance()); 289 } 290 { 291 DefaultManagedObject.Builder<BackendIndexCfgClient, BackendIndexCfg> dmoBuilder = new DefaultManagedObject.Builder<BackendIndexCfgClient, BackendIndexCfg>(BackendIndexCfgDefn.getInstance()); 292 dmoBuilder.setPropertyValues("index-type", "equality"); 293 dmoBuilder.setPropertyValues("attribute", "objectClass"); 294 builder.setDefaultManagedObject("objectClass", dmoBuilder.getInstance()); 295 } 296 { 297 DefaultManagedObject.Builder<BackendIndexCfgClient, BackendIndexCfg> dmoBuilder = new DefaultManagedObject.Builder<BackendIndexCfgClient, BackendIndexCfg>(BackendIndexCfgDefn.getInstance()); 298 dmoBuilder.setPropertyValues("index-type", "ordering"); 299 dmoBuilder.setPropertyValues("attribute", "ds-sync-hist"); 300 builder.setDefaultManagedObject("ds-sync-hist", dmoBuilder.getInstance()); 301 } 302 { 303 DefaultManagedObject.Builder<BackendIndexCfgClient, BackendIndexCfg> dmoBuilder = new DefaultManagedObject.Builder<BackendIndexCfgClient, BackendIndexCfg>(BackendIndexCfgDefn.getInstance()); 304 dmoBuilder.setPropertyValues("index-type", "equality"); 305 dmoBuilder.setPropertyValues("attribute", "ds-sync-conflict"); 306 builder.setDefaultManagedObject("ds-sync-conflict", dmoBuilder.getInstance()); 307 } 308 RD_BACKEND_INDEXES = builder.getInstance(); 309 INSTANCE.registerRelationDefinition(RD_BACKEND_INDEXES); 310 } 311 312 313 314 // Build the "backend-vlv-indexes" relation definition. 315 static { 316 InstantiableRelationDefinition.Builder<BackendVLVIndexCfgClient, BackendVLVIndexCfg> builder = 317 new InstantiableRelationDefinition.Builder<BackendVLVIndexCfgClient, BackendVLVIndexCfg>(INSTANCE, "backend-vlv-index", "backend-vlv-indexes", BackendVLVIndexCfgDefn.getInstance()); 318 builder.setNamingProperty(BackendVLVIndexCfgDefn.getInstance().getNamePropertyDefinition()); 319 RD_BACKEND_VLV_INDEXES = builder.getInstance(); 320 INSTANCE.registerRelationDefinition(RD_BACKEND_VLV_INDEXES); 321 } 322 323 324 325 // Register the tags associated with this managed object definition. 326 static { 327 INSTANCE.registerTag(Tag.valueOf("database")); 328 } 329 330 331 332 /** 333 * Get the Pluggable Backend configuration definition singleton. 334 * 335 * @return Returns the Pluggable Backend configuration definition 336 * singleton. 337 */ 338 public static PluggableBackendCfgDefn getInstance() { 339 return INSTANCE; 340 } 341 342 343 344 /** 345 * Private constructor. 346 */ 347 private PluggableBackendCfgDefn() { 348 super("pluggable-backend", BackendCfgDefn.getInstance()); 349 } 350 351 352 353 /** 354 * Get the "backend-id" property definition. 355 * <p> 356 * Specifies a name to identify the associated backend. 357 * <p> 358 * The name must be unique among all backends in the server. The 359 * backend ID may not be altered after the backend is created in the 360 * server. 361 * 362 * @return Returns the "backend-id" property definition. 363 */ 364 public StringPropertyDefinition getBackendIdPropertyDefinition() { 365 return BackendCfgDefn.getInstance().getBackendIdPropertyDefinition(); 366 } 367 368 369 370 /** 371 * Get the "base-dn" property definition. 372 * <p> 373 * Specifies the base DN(s) for the data that the backend handles. 374 * <p> 375 * A single backend may be responsible for one or more base DNs. 376 * Note that no two backends may have the same base DN although one 377 * backend may have a base DN that is below a base DN provided by 378 * another backend (similar to the use of sub-suffixes in the Sun 379 * Java System Directory Server). If any of the base DNs is 380 * subordinate to a base DN for another backend, then all base DNs 381 * for that backend must be subordinate to that same base DN. 382 * 383 * @return Returns the "base-dn" property definition. 384 */ 385 public DNPropertyDefinition getBaseDNPropertyDefinition() { 386 return BackendCfgDefn.getInstance().getBaseDNPropertyDefinition(); 387 } 388 389 390 391 /** 392 * Get the "cipher-key-length" property definition. 393 * <p> 394 * Specifies the key length in bits for the preferred cipher. 395 * 396 * @return Returns the "cipher-key-length" property definition. 397 */ 398 public IntegerPropertyDefinition getCipherKeyLengthPropertyDefinition() { 399 return PD_CIPHER_KEY_LENGTH; 400 } 401 402 403 404 /** 405 * Get the "cipher-transformation" property definition. 406 * <p> 407 * Specifies the cipher for the directory server. The syntax is 408 * "algorithm/mode/padding". 409 * <p> 410 * The full transformation is required: specifying only an algorithm 411 * and allowing the cipher provider to supply the default mode and 412 * padding is not supported, because there is no guarantee these 413 * default values are the same among different implementations. Some 414 * cipher algorithms, including RC4 and ARCFOUR, do not have a mode 415 * or padding, and hence must be specified using NONE for the mode 416 * field and NoPadding for the padding field. For example, 417 * RC4/NONE/NoPadding. 418 * 419 * @return Returns the "cipher-transformation" property definition. 420 */ 421 public StringPropertyDefinition getCipherTransformationPropertyDefinition() { 422 return PD_CIPHER_TRANSFORMATION; 423 } 424 425 426 427 /** 428 * Get the "compact-encoding" property definition. 429 * <p> 430 * Indicates whether the backend should use a compact form when 431 * encoding entries by compressing the attribute descriptions and 432 * object class sets. 433 * <p> 434 * Note that this property applies only to the entries themselves 435 * and does not impact the index data. 436 * 437 * @return Returns the "compact-encoding" property definition. 438 */ 439 public BooleanPropertyDefinition getCompactEncodingPropertyDefinition() { 440 return PD_COMPACT_ENCODING; 441 } 442 443 444 445 /** 446 * Get the "confidentiality-enabled" property definition. 447 * <p> 448 * Indicates whether the backend should make entries in database 449 * files readable only by Directory Server. 450 * <p> 451 * Confidentiality is achieved by enrypting entries before writing 452 * them to the underlying storage. Entry encryption will protect data 453 * on disk from unauthorised parties reading the files; for complete 454 * protection, also set confidentiality for sensitive attributes 455 * indexes. The property cannot be set to false if some of the 456 * indexes have confidentiality set to true. 457 * 458 * @return Returns the "confidentiality-enabled" property definition. 459 */ 460 public BooleanPropertyDefinition getConfidentialityEnabledPropertyDefinition() { 461 return PD_CONFIDENTIALITY_ENABLED; 462 } 463 464 465 466 /** 467 * Get the "enabled" property definition. 468 * <p> 469 * Indicates whether the backend is enabled in the server. 470 * <p> 471 * If a backend is not enabled, then its contents are not accessible 472 * when processing operations. 473 * 474 * @return Returns the "enabled" property definition. 475 */ 476 public BooleanPropertyDefinition getEnabledPropertyDefinition() { 477 return BackendCfgDefn.getInstance().getEnabledPropertyDefinition(); 478 } 479 480 481 482 /** 483 * Get the "entries-compressed" property definition. 484 * <p> 485 * Indicates whether the backend should attempt to compress entries 486 * before storing them in the database. 487 * <p> 488 * Note that this property applies only to the entries themselves 489 * and does not impact the index data. Further, the effectiveness of 490 * the compression is based on the type of data contained in the 491 * entry. 492 * 493 * @return Returns the "entries-compressed" property definition. 494 */ 495 public BooleanPropertyDefinition getEntriesCompressedPropertyDefinition() { 496 return PD_ENTRIES_COMPRESSED; 497 } 498 499 500 501 /** 502 * Get the "import-offheap-memory-size" property definition. 503 * <p> 504 * Specifies the amount of off-heap memory dedicated to the online 505 * operation (import-ldif, rebuild-index). 506 * 507 * @return Returns the "import-offheap-memory-size" property definition. 508 */ 509 public SizePropertyDefinition getImportOffheapMemorySizePropertyDefinition() { 510 return PD_IMPORT_OFFHEAP_MEMORY_SIZE; 511 } 512 513 514 515 /** 516 * Get the "index-entry-limit" property definition. 517 * <p> 518 * Specifies the maximum number of entries that is allowed to match 519 * a given index key before that particular index key is no longer 520 * maintained. 521 * <p> 522 * This property is analogous to the ALL IDs threshold in the Sun 523 * Java System Directory Server. Note that this is the default limit 524 * for the backend, and it may be overridden on a per-attribute 525 * basis.A value of 0 means there is no limit. 526 * 527 * @return Returns the "index-entry-limit" property definition. 528 */ 529 public IntegerPropertyDefinition getIndexEntryLimitPropertyDefinition() { 530 return PD_INDEX_ENTRY_LIMIT; 531 } 532 533 534 535 /** 536 * Get the "index-filter-analyzer-enabled" property definition. 537 * <p> 538 * Indicates whether to gather statistical information about the 539 * search filters processed by the directory server while evaluating 540 * the usage of indexes. 541 * <p> 542 * Analyzing indexes requires gathering search filter usage patterns 543 * from user requests, especially for values as specified in the 544 * filters and subsequently looking the status of those values into 545 * the index files. When a search requests is processed, internal or 546 * user generated, a first phase uses indexes to find potential 547 * entries to be returned. Depending on the search filter, if the 548 * index of one of the specified attributes matches too many entries 549 * (exceeds the index entry limit), the search becomes non-indexed. 550 * In any case, all entries thus gathered (or the entire DIT) are 551 * matched against the filter for actually returning the search 552 * result. 553 * 554 * @return Returns the "index-filter-analyzer-enabled" property definition. 555 */ 556 public BooleanPropertyDefinition getIndexFilterAnalyzerEnabledPropertyDefinition() { 557 return PD_INDEX_FILTER_ANALYZER_ENABLED; 558 } 559 560 561 562 /** 563 * Get the "index-filter-analyzer-max-filters" property definition. 564 * <p> 565 * The maximum number of search filter statistics to keep. 566 * <p> 567 * When the maximum number of search filter is reached, the least 568 * used one will be deleted. 569 * 570 * @return Returns the "index-filter-analyzer-max-filters" property definition. 571 */ 572 public IntegerPropertyDefinition getIndexFilterAnalyzerMaxFiltersPropertyDefinition() { 573 return PD_INDEX_FILTER_ANALYZER_MAX_FILTERS; 574 } 575 576 577 578 /** 579 * Get the "java-class" property definition. 580 * <p> 581 * Specifies the fully-qualified name of the Java class that 582 * provides the backend implementation. 583 * 584 * @return Returns the "java-class" property definition. 585 */ 586 public ClassPropertyDefinition getJavaClassPropertyDefinition() { 587 return BackendCfgDefn.getInstance().getJavaClassPropertyDefinition(); 588 } 589 590 591 592 /** 593 * Get the "preload-time-limit" property definition. 594 * <p> 595 * Specifies the length of time that the backend is allowed to spend 596 * "pre-loading" data when it is initialized. 597 * <p> 598 * The pre-load process is used to pre-populate the database cache, 599 * so that it can be more quickly available when the server is 600 * processing requests. A duration of zero means there is no 601 * pre-load. 602 * 603 * @return Returns the "preload-time-limit" property definition. 604 */ 605 public DurationPropertyDefinition getPreloadTimeLimitPropertyDefinition() { 606 return PD_PRELOAD_TIME_LIMIT; 607 } 608 609 610 611 /** 612 * Get the "writability-mode" property definition. 613 * <p> 614 * Specifies the behavior that the backend should use when 615 * processing write operations. 616 * 617 * @return Returns the "writability-mode" property definition. 618 */ 619 public EnumPropertyDefinition<WritabilityMode> getWritabilityModePropertyDefinition() { 620 return PD_WRITABILITY_MODE; 621 } 622 623 624 625 /** 626 * Get the "backend-indexes" relation definition. 627 * 628 * @return Returns the "backend-indexes" relation definition. 629 */ 630 public InstantiableRelationDefinition<BackendIndexCfgClient,BackendIndexCfg> getBackendIndexesRelationDefinition() { 631 return RD_BACKEND_INDEXES; 632 } 633 634 635 636 /** 637 * Get the "backend-vlv-indexes" relation definition. 638 * 639 * @return Returns the "backend-vlv-indexes" relation definition. 640 */ 641 public InstantiableRelationDefinition<BackendVLVIndexCfgClient,BackendVLVIndexCfg> getBackendVLVIndexesRelationDefinition() { 642 return RD_BACKEND_VLV_INDEXES; 643 } 644}