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}