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 java.util.TreeSet;
033import org.forgerock.opendj.config.AdministratorAction;
034import org.forgerock.opendj.config.AggregationPropertyDefinition;
035import org.forgerock.opendj.config.AliasDefaultBehaviorProvider;
036import org.forgerock.opendj.config.BooleanPropertyDefinition;
037import org.forgerock.opendj.config.ClassPropertyDefinition;
038import org.forgerock.opendj.config.client.ConcurrentModificationException;
039import org.forgerock.opendj.config.client.IllegalManagedObjectNameException;
040import org.forgerock.opendj.config.client.ManagedObject;
041import org.forgerock.opendj.config.client.ManagedObjectDecodingException;
042import org.forgerock.opendj.config.client.MissingMandatoryPropertiesException;
043import org.forgerock.opendj.config.client.OperationRejectedException;
044import org.forgerock.opendj.config.DefaultBehaviorProvider;
045import org.forgerock.opendj.config.DefinedDefaultBehaviorProvider;
046import org.forgerock.opendj.config.DefinitionDecodingException;
047import org.forgerock.opendj.config.DurationPropertyDefinition;
048import org.forgerock.opendj.config.EnumPropertyDefinition;
049import org.forgerock.opendj.config.InstantiableRelationDefinition;
050import org.forgerock.opendj.config.IntegerPropertyDefinition;
051import org.forgerock.opendj.config.ManagedObjectAlreadyExistsException;
052import org.forgerock.opendj.config.ManagedObjectDefinition;
053import org.forgerock.opendj.config.ManagedObjectNotFoundException;
054import org.forgerock.opendj.config.PropertyException;
055import org.forgerock.opendj.config.PropertyOption;
056import org.forgerock.opendj.config.PropertyProvider;
057import org.forgerock.opendj.config.server.ConfigException;
058import org.forgerock.opendj.config.server.ConfigurationAddListener;
059import org.forgerock.opendj.config.server.ConfigurationChangeListener;
060import org.forgerock.opendj.config.server.ConfigurationDeleteListener;
061import org.forgerock.opendj.config.server.ServerManagedObject;
062import org.forgerock.opendj.config.SizePropertyDefinition;
063import org.forgerock.opendj.config.StringPropertyDefinition;
064import org.forgerock.opendj.config.Tag;
065import org.forgerock.opendj.config.UndefinedDefaultBehaviorProvider;
066import org.forgerock.opendj.ldap.DN;
067import org.forgerock.opendj.ldap.LdapException;
068import org.forgerock.opendj.server.config.client.AccessLogFilteringCriteriaCfgClient;
069import org.forgerock.opendj.server.config.client.FileBasedAccessLogPublisherCfgClient;
070import org.forgerock.opendj.server.config.client.LogRetentionPolicyCfgClient;
071import org.forgerock.opendj.server.config.client.LogRotationPolicyCfgClient;
072import org.forgerock.opendj.server.config.meta.AccessLogPublisherCfgDefn.FilteringPolicy;
073import org.forgerock.opendj.server.config.server.AccessLogFilteringCriteriaCfg;
074import org.forgerock.opendj.server.config.server.AccessLogPublisherCfg;
075import org.forgerock.opendj.server.config.server.FileBasedAccessLogPublisherCfg;
076import org.forgerock.opendj.server.config.server.LogPublisherCfg;
077import org.forgerock.opendj.server.config.server.LogRetentionPolicyCfg;
078import org.forgerock.opendj.server.config.server.LogRotationPolicyCfg;
079
080
081
082/**
083 * An interface for querying the File Based Access Log Publisher
084 * managed object definition meta information.
085 * <p>
086 * File Based Access Log Publishers publish access messages to the
087 * file system.
088 */
089public final class FileBasedAccessLogPublisherCfgDefn extends ManagedObjectDefinition<FileBasedAccessLogPublisherCfgClient, FileBasedAccessLogPublisherCfg> {
090
091  // The singleton configuration definition instance.
092  private static final FileBasedAccessLogPublisherCfgDefn INSTANCE = new FileBasedAccessLogPublisherCfgDefn();
093
094
095
096  /**
097   * Defines the set of permissable values for the "log-format" property.
098   * <p>
099   * Specifies how log records should be formatted and written to the
100   * access log.
101   */
102  public static enum LogFormat {
103
104    /**
105     * Combine log records for operation requests and responses into a
106     * single record. This format should be used when log records are
107     * to be filtered based on response criteria (e.g. result code).
108     */
109    COMBINED("combined"),
110
111
112
113    /**
114     * Outputs separate log records for operation requests and
115     * responses.
116     */
117    MULTI_LINE("multi-line");
118
119
120
121    // String representation of the value.
122    private final String name;
123
124
125
126    // Private constructor.
127    private LogFormat(String name) { this.name = name; }
128
129
130
131    /**
132     * {@inheritDoc}
133     */
134    public String toString() { return name; }
135
136  }
137
138
139
140  // The "append" property definition.
141  private static final BooleanPropertyDefinition PD_APPEND;
142
143
144
145  // The "asynchronous" property definition.
146  private static final BooleanPropertyDefinition PD_ASYNCHRONOUS;
147
148
149
150  // The "auto-flush" property definition.
151  private static final BooleanPropertyDefinition PD_AUTO_FLUSH;
152
153
154
155  // The "buffer-size" property definition.
156  private static final SizePropertyDefinition PD_BUFFER_SIZE;
157
158
159
160  // The "java-class" property definition.
161  private static final ClassPropertyDefinition PD_JAVA_CLASS;
162
163
164
165  // The "log-control-oids" property definition.
166  private static final BooleanPropertyDefinition PD_LOG_CONTROL_OIDS;
167
168
169
170  // The "log-file" property definition.
171  private static final StringPropertyDefinition PD_LOG_FILE;
172
173
174
175  // The "log-file-permissions" property definition.
176  private static final StringPropertyDefinition PD_LOG_FILE_PERMISSIONS;
177
178
179
180  // The "log-format" property definition.
181  private static final EnumPropertyDefinition<LogFormat> PD_LOG_FORMAT;
182
183
184
185  // The "log-record-time-format" property definition.
186  private static final StringPropertyDefinition PD_LOG_RECORD_TIME_FORMAT;
187
188
189
190  // The "queue-size" property definition.
191  private static final IntegerPropertyDefinition PD_QUEUE_SIZE;
192
193
194
195  // The "retention-policy" property definition.
196  private static final AggregationPropertyDefinition<LogRetentionPolicyCfgClient, LogRetentionPolicyCfg> PD_RETENTION_POLICY;
197
198
199
200  // The "rotation-policy" property definition.
201  private static final AggregationPropertyDefinition<LogRotationPolicyCfgClient, LogRotationPolicyCfg> PD_ROTATION_POLICY;
202
203
204
205  // The "time-interval" property definition.
206  private static final DurationPropertyDefinition PD_TIME_INTERVAL;
207
208
209
210  // Build the "append" property definition.
211  static {
212      BooleanPropertyDefinition.Builder builder = BooleanPropertyDefinition.createBuilder(INSTANCE, "append");
213      builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "append"));
214      DefaultBehaviorProvider<Boolean> provider = new DefinedDefaultBehaviorProvider<Boolean>("true");
215      builder.setDefaultBehaviorProvider(provider);
216      PD_APPEND = builder.getInstance();
217      INSTANCE.registerPropertyDefinition(PD_APPEND);
218  }
219
220
221
222  // Build the "asynchronous" property definition.
223  static {
224      BooleanPropertyDefinition.Builder builder = BooleanPropertyDefinition.createBuilder(INSTANCE, "asynchronous");
225      builder.setOption(PropertyOption.MANDATORY);
226      builder.setOption(PropertyOption.ADVANCED);
227      builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "asynchronous"));
228      DefaultBehaviorProvider<Boolean> provider = new DefinedDefaultBehaviorProvider<Boolean>("true");
229      builder.setDefaultBehaviorProvider(provider);
230      PD_ASYNCHRONOUS = builder.getInstance();
231      INSTANCE.registerPropertyDefinition(PD_ASYNCHRONOUS);
232  }
233
234
235
236  // Build the "auto-flush" property definition.
237  static {
238      BooleanPropertyDefinition.Builder builder = BooleanPropertyDefinition.createBuilder(INSTANCE, "auto-flush");
239      builder.setOption(PropertyOption.ADVANCED);
240      builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "auto-flush"));
241      DefaultBehaviorProvider<Boolean> provider = new DefinedDefaultBehaviorProvider<Boolean>("true");
242      builder.setDefaultBehaviorProvider(provider);
243      PD_AUTO_FLUSH = builder.getInstance();
244      INSTANCE.registerPropertyDefinition(PD_AUTO_FLUSH);
245  }
246
247
248
249  // Build the "buffer-size" property definition.
250  static {
251      SizePropertyDefinition.Builder builder = SizePropertyDefinition.createBuilder(INSTANCE, "buffer-size");
252      builder.setOption(PropertyOption.ADVANCED);
253      builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "buffer-size"));
254      DefaultBehaviorProvider<Long> provider = new DefinedDefaultBehaviorProvider<Long>("64kb");
255      builder.setDefaultBehaviorProvider(provider);
256      builder.setLowerLimit("1");
257      PD_BUFFER_SIZE = builder.getInstance();
258      INSTANCE.registerPropertyDefinition(PD_BUFFER_SIZE);
259  }
260
261
262
263  // Build the "java-class" property definition.
264  static {
265      ClassPropertyDefinition.Builder builder = ClassPropertyDefinition.createBuilder(INSTANCE, "java-class");
266      builder.setOption(PropertyOption.MANDATORY);
267      builder.setOption(PropertyOption.ADVANCED);
268      builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "java-class"));
269      DefaultBehaviorProvider<String> provider = new DefinedDefaultBehaviorProvider<String>("org.opends.server.loggers.TextAccessLogPublisher");
270      builder.setDefaultBehaviorProvider(provider);
271      builder.addInstanceOf("org.opends.server.loggers.LogPublisher");
272      PD_JAVA_CLASS = builder.getInstance();
273      INSTANCE.registerPropertyDefinition(PD_JAVA_CLASS);
274  }
275
276
277
278  // Build the "log-control-oids" property definition.
279  static {
280      BooleanPropertyDefinition.Builder builder = BooleanPropertyDefinition.createBuilder(INSTANCE, "log-control-oids");
281      builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "log-control-oids"));
282      DefaultBehaviorProvider<Boolean> provider = new DefinedDefaultBehaviorProvider<Boolean>("false");
283      builder.setDefaultBehaviorProvider(provider);
284      PD_LOG_CONTROL_OIDS = builder.getInstance();
285      INSTANCE.registerPropertyDefinition(PD_LOG_CONTROL_OIDS);
286  }
287
288
289
290  // Build the "log-file" property definition.
291  static {
292      StringPropertyDefinition.Builder builder = StringPropertyDefinition.createBuilder(INSTANCE, "log-file");
293      builder.setOption(PropertyOption.MANDATORY);
294      builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.COMPONENT_RESTART, INSTANCE, "log-file"));
295      builder.setDefaultBehaviorProvider(new UndefinedDefaultBehaviorProvider<String>());
296      builder.setPattern(".*", "FILE");
297      PD_LOG_FILE = builder.getInstance();
298      INSTANCE.registerPropertyDefinition(PD_LOG_FILE);
299  }
300
301
302
303  // Build the "log-file-permissions" property definition.
304  static {
305      StringPropertyDefinition.Builder builder = StringPropertyDefinition.createBuilder(INSTANCE, "log-file-permissions");
306      builder.setOption(PropertyOption.MANDATORY);
307      builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "log-file-permissions"));
308      DefaultBehaviorProvider<String> provider = new DefinedDefaultBehaviorProvider<String>("640");
309      builder.setDefaultBehaviorProvider(provider);
310      builder.setPattern("^([0-7][0-7][0-7])$", "MODE");
311      PD_LOG_FILE_PERMISSIONS = builder.getInstance();
312      INSTANCE.registerPropertyDefinition(PD_LOG_FILE_PERMISSIONS);
313  }
314
315
316
317  // Build the "log-format" property definition.
318  static {
319      EnumPropertyDefinition.Builder<LogFormat> builder = EnumPropertyDefinition.createBuilder(INSTANCE, "log-format");
320      builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "log-format"));
321      DefaultBehaviorProvider<LogFormat> provider = new DefinedDefaultBehaviorProvider<LogFormat>("multi-line");
322      builder.setDefaultBehaviorProvider(provider);
323      builder.setEnumClass(LogFormat.class);
324      PD_LOG_FORMAT = builder.getInstance();
325      INSTANCE.registerPropertyDefinition(PD_LOG_FORMAT);
326  }
327
328
329
330  // Build the "log-record-time-format" property definition.
331  static {
332      StringPropertyDefinition.Builder builder = StringPropertyDefinition.createBuilder(INSTANCE, "log-record-time-format");
333      builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "log-record-time-format"));
334      DefaultBehaviorProvider<String> provider = new DefinedDefaultBehaviorProvider<String>("dd/MMM/yyyy:HH:mm:ss Z");
335      builder.setDefaultBehaviorProvider(provider);
336      builder.setPattern(".*", "STRING");
337      PD_LOG_RECORD_TIME_FORMAT = builder.getInstance();
338      INSTANCE.registerPropertyDefinition(PD_LOG_RECORD_TIME_FORMAT);
339  }
340
341
342
343  // Build the "queue-size" property definition.
344  static {
345      IntegerPropertyDefinition.Builder builder = IntegerPropertyDefinition.createBuilder(INSTANCE, "queue-size");
346      builder.setOption(PropertyOption.ADVANCED);
347      builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.OTHER, INSTANCE, "queue-size"));
348      DefaultBehaviorProvider<Integer> provider = new DefinedDefaultBehaviorProvider<Integer>("5000");
349      builder.setDefaultBehaviorProvider(provider);
350      builder.setLowerLimit(0);
351      PD_QUEUE_SIZE = builder.getInstance();
352      INSTANCE.registerPropertyDefinition(PD_QUEUE_SIZE);
353  }
354
355
356
357  // Build the "retention-policy" property definition.
358  static {
359      AggregationPropertyDefinition.Builder<LogRetentionPolicyCfgClient, LogRetentionPolicyCfg> builder = AggregationPropertyDefinition.createBuilder(INSTANCE, "retention-policy");
360      builder.setOption(PropertyOption.MULTI_VALUED);
361      builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "retention-policy"));
362      builder.setDefaultBehaviorProvider(new AliasDefaultBehaviorProvider<String>(INSTANCE, "retention-policy"));
363      builder.setParentPath("/");
364      builder.setRelationDefinition("log-retention-policy");
365      PD_RETENTION_POLICY = builder.getInstance();
366      INSTANCE.registerPropertyDefinition(PD_RETENTION_POLICY);
367      INSTANCE.registerConstraint(PD_RETENTION_POLICY.getSourceConstraint());
368  }
369
370
371
372  // Build the "rotation-policy" property definition.
373  static {
374      AggregationPropertyDefinition.Builder<LogRotationPolicyCfgClient, LogRotationPolicyCfg> builder = AggregationPropertyDefinition.createBuilder(INSTANCE, "rotation-policy");
375      builder.setOption(PropertyOption.MULTI_VALUED);
376      builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "rotation-policy"));
377      builder.setDefaultBehaviorProvider(new AliasDefaultBehaviorProvider<String>(INSTANCE, "rotation-policy"));
378      builder.setParentPath("/");
379      builder.setRelationDefinition("log-rotation-policy");
380      PD_ROTATION_POLICY = builder.getInstance();
381      INSTANCE.registerPropertyDefinition(PD_ROTATION_POLICY);
382      INSTANCE.registerConstraint(PD_ROTATION_POLICY.getSourceConstraint());
383  }
384
385
386
387  // Build the "time-interval" property definition.
388  static {
389      DurationPropertyDefinition.Builder builder = DurationPropertyDefinition.createBuilder(INSTANCE, "time-interval");
390      builder.setOption(PropertyOption.ADVANCED);
391      builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "time-interval"));
392      DefaultBehaviorProvider<Long> provider = new DefinedDefaultBehaviorProvider<Long>("5s");
393      builder.setDefaultBehaviorProvider(provider);
394      builder.setBaseUnit("ms");
395      builder.setLowerLimit("1");
396      PD_TIME_INTERVAL = builder.getInstance();
397      INSTANCE.registerPropertyDefinition(PD_TIME_INTERVAL);
398  }
399
400
401
402  // Register the tags associated with this managed object definition.
403  static {
404    INSTANCE.registerTag(Tag.valueOf("logging"));
405  }
406
407
408
409  /**
410   * Get the File Based Access Log Publisher configuration definition
411   * singleton.
412   *
413   * @return Returns the File Based Access Log Publisher configuration
414   *         definition singleton.
415   */
416  public static FileBasedAccessLogPublisherCfgDefn getInstance() {
417    return INSTANCE;
418  }
419
420
421
422  /**
423   * Private constructor.
424   */
425  private FileBasedAccessLogPublisherCfgDefn() {
426    super("file-based-access-log-publisher", AccessLogPublisherCfgDefn.getInstance());
427  }
428
429
430
431  /**
432   * {@inheritDoc}
433   */
434  public FileBasedAccessLogPublisherCfgClient createClientConfiguration(
435      ManagedObject<? extends FileBasedAccessLogPublisherCfgClient> impl) {
436    return new FileBasedAccessLogPublisherCfgClientImpl(impl);
437  }
438
439
440
441  /**
442   * {@inheritDoc}
443   */
444  public FileBasedAccessLogPublisherCfg createServerConfiguration(
445      ServerManagedObject<? extends FileBasedAccessLogPublisherCfg> impl) {
446    return new FileBasedAccessLogPublisherCfgServerImpl(impl);
447  }
448
449
450
451  /**
452   * {@inheritDoc}
453   */
454  public Class<FileBasedAccessLogPublisherCfg> getServerConfigurationClass() {
455    return FileBasedAccessLogPublisherCfg.class;
456  }
457
458
459
460  /**
461   * Get the "append" property definition.
462   * <p>
463   * Specifies whether to append to existing log files.
464   *
465   * @return Returns the "append" property definition.
466   */
467  public BooleanPropertyDefinition getAppendPropertyDefinition() {
468    return PD_APPEND;
469  }
470
471
472
473  /**
474   * Get the "asynchronous" property definition.
475   * <p>
476   * Indicates whether the File Based Access Log Publisher will
477   * publish records asynchronously.
478   *
479   * @return Returns the "asynchronous" property definition.
480   */
481  public BooleanPropertyDefinition getAsynchronousPropertyDefinition() {
482    return PD_ASYNCHRONOUS;
483  }
484
485
486
487  /**
488   * Get the "auto-flush" property definition.
489   * <p>
490   * Specifies whether to flush the writer after every log record.
491   * <p>
492   * If the asynchronous writes option is used, the writer is flushed
493   * after all the log records in the queue are written.
494   *
495   * @return Returns the "auto-flush" property definition.
496   */
497  public BooleanPropertyDefinition getAutoFlushPropertyDefinition() {
498    return PD_AUTO_FLUSH;
499  }
500
501
502
503  /**
504   * Get the "buffer-size" property definition.
505   * <p>
506   * Specifies the log file buffer size.
507   *
508   * @return Returns the "buffer-size" property definition.
509   */
510  public SizePropertyDefinition getBufferSizePropertyDefinition() {
511    return PD_BUFFER_SIZE;
512  }
513
514
515
516  /**
517   * Get the "enabled" property definition.
518   * <p>
519   * Indicates whether the File Based Access Log Publisher is enabled
520   * for use.
521   *
522   * @return Returns the "enabled" property definition.
523   */
524  public BooleanPropertyDefinition getEnabledPropertyDefinition() {
525    return AccessLogPublisherCfgDefn.getInstance().getEnabledPropertyDefinition();
526  }
527
528
529
530  /**
531   * Get the "filtering-policy" property definition.
532   * <p>
533   * Specifies how filtering criteria should be applied to log
534   * records.
535   *
536   * @return Returns the "filtering-policy" property definition.
537   */
538  public EnumPropertyDefinition<FilteringPolicy> getFilteringPolicyPropertyDefinition() {
539    return AccessLogPublisherCfgDefn.getInstance().getFilteringPolicyPropertyDefinition();
540  }
541
542
543
544  /**
545   * Get the "java-class" property definition.
546   * <p>
547   * The fully-qualified name of the Java class that provides the File
548   * Based Access Log Publisher implementation.
549   *
550   * @return Returns the "java-class" property definition.
551   */
552  public ClassPropertyDefinition getJavaClassPropertyDefinition() {
553    return PD_JAVA_CLASS;
554  }
555
556
557
558  /**
559   * Get the "log-control-oids" property definition.
560   * <p>
561   * Specifies whether control OIDs will be included in operation log
562   * records.
563   *
564   * @return Returns the "log-control-oids" property definition.
565   */
566  public BooleanPropertyDefinition getLogControlOidsPropertyDefinition() {
567    return PD_LOG_CONTROL_OIDS;
568  }
569
570
571
572  /**
573   * Get the "log-file" property definition.
574   * <p>
575   * The file name to use for the log files generated by the File
576   * Based Access Log Publisher. The path to the file is relative to
577   * the server root.
578   *
579   * @return Returns the "log-file" property definition.
580   */
581  public StringPropertyDefinition getLogFilePropertyDefinition() {
582    return PD_LOG_FILE;
583  }
584
585
586
587  /**
588   * Get the "log-file-permissions" property definition.
589   * <p>
590   * The UNIX permissions of the log files created by this File Based
591   * Access Log Publisher.
592   *
593   * @return Returns the "log-file-permissions" property definition.
594   */
595  public StringPropertyDefinition getLogFilePermissionsPropertyDefinition() {
596    return PD_LOG_FILE_PERMISSIONS;
597  }
598
599
600
601  /**
602   * Get the "log-format" property definition.
603   * <p>
604   * Specifies how log records should be formatted and written to the
605   * access log.
606   *
607   * @return Returns the "log-format" property definition.
608   */
609  public EnumPropertyDefinition<LogFormat> getLogFormatPropertyDefinition() {
610    return PD_LOG_FORMAT;
611  }
612
613
614
615  /**
616   * Get the "log-record-time-format" property definition.
617   * <p>
618   * Specifies the format string that is used to generate log record
619   * timestamps.
620   *
621   * @return Returns the "log-record-time-format" property definition.
622   */
623  public StringPropertyDefinition getLogRecordTimeFormatPropertyDefinition() {
624    return PD_LOG_RECORD_TIME_FORMAT;
625  }
626
627
628
629  /**
630   * Get the "queue-size" property definition.
631   * <p>
632   * The maximum number of log records that can be stored in the
633   * asynchronous queue.
634   * <p>
635   * Setting the queue size to zero activates parallel log writer
636   * implementation which has no queue size limit and as such the
637   * parallel log writer should only be used on a very well tuned
638   * server configuration to avoid potential out of memory errors.
639   *
640   * @return Returns the "queue-size" property definition.
641   */
642  public IntegerPropertyDefinition getQueueSizePropertyDefinition() {
643    return PD_QUEUE_SIZE;
644  }
645
646
647
648  /**
649   * Get the "retention-policy" property definition.
650   * <p>
651   * The retention policy to use for the File Based Access Log
652   * Publisher .
653   * <p>
654   * When multiple policies are used, log files are cleaned when any
655   * of the policy's conditions are met.
656   *
657   * @return Returns the "retention-policy" property definition.
658   */
659  public AggregationPropertyDefinition<LogRetentionPolicyCfgClient, LogRetentionPolicyCfg> getRetentionPolicyPropertyDefinition() {
660    return PD_RETENTION_POLICY;
661  }
662
663
664
665  /**
666   * Get the "rotation-policy" property definition.
667   * <p>
668   * The rotation policy to use for the File Based Access Log
669   * Publisher .
670   * <p>
671   * When multiple policies are used, rotation will occur if any
672   * policy's conditions are met.
673   *
674   * @return Returns the "rotation-policy" property definition.
675   */
676  public AggregationPropertyDefinition<LogRotationPolicyCfgClient, LogRotationPolicyCfg> getRotationPolicyPropertyDefinition() {
677    return PD_ROTATION_POLICY;
678  }
679
680
681
682  /**
683   * Get the "suppress-internal-operations" property definition.
684   * <p>
685   * Indicates whether internal operations (for example, operations
686   * that are initiated by plugins) should be logged along with the
687   * operations that are requested by users.
688   *
689   * @return Returns the "suppress-internal-operations" property definition.
690   */
691  public BooleanPropertyDefinition getSuppressInternalOperationsPropertyDefinition() {
692    return AccessLogPublisherCfgDefn.getInstance().getSuppressInternalOperationsPropertyDefinition();
693  }
694
695
696
697  /**
698   * Get the "suppress-synchronization-operations" property definition.
699   * <p>
700   * Indicates whether access messages that are generated by
701   * synchronization operations should be suppressed.
702   *
703   * @return Returns the "suppress-synchronization-operations" property definition.
704   */
705  public BooleanPropertyDefinition getSuppressSynchronizationOperationsPropertyDefinition() {
706    return AccessLogPublisherCfgDefn.getInstance().getSuppressSynchronizationOperationsPropertyDefinition();
707  }
708
709
710
711  /**
712   * Get the "time-interval" property definition.
713   * <p>
714   * Specifies the interval at which to check whether the log files
715   * need to be rotated.
716   *
717   * @return Returns the "time-interval" property definition.
718   */
719  public DurationPropertyDefinition getTimeIntervalPropertyDefinition() {
720    return PD_TIME_INTERVAL;
721  }
722
723
724
725  /**
726   * Get the "access-log-filtering-criteria" relation definition.
727   *
728   * @return Returns the "access-log-filtering-criteria" relation definition.
729   */
730  public InstantiableRelationDefinition<AccessLogFilteringCriteriaCfgClient,AccessLogFilteringCriteriaCfg> getAccessLogFilteringCriteriaRelationDefinition() {
731    return AccessLogPublisherCfgDefn.getInstance().getAccessLogFilteringCriteriaRelationDefinition();
732  }
733
734
735
736  /**
737   * Managed object client implementation.
738   */
739  private static class FileBasedAccessLogPublisherCfgClientImpl implements
740    FileBasedAccessLogPublisherCfgClient {
741
742    // Private implementation.
743    private ManagedObject<? extends FileBasedAccessLogPublisherCfgClient> impl;
744
745
746
747    // Private constructor.
748    private FileBasedAccessLogPublisherCfgClientImpl(
749        ManagedObject<? extends FileBasedAccessLogPublisherCfgClient> impl) {
750      this.impl = impl;
751    }
752
753
754
755    /**
756     * {@inheritDoc}
757     */
758    public boolean isAppend() {
759      return impl.getPropertyValue(INSTANCE.getAppendPropertyDefinition());
760    }
761
762
763
764    /**
765     * {@inheritDoc}
766     */
767    public void setAppend(Boolean value) {
768      impl.setPropertyValue(INSTANCE.getAppendPropertyDefinition(), value);
769    }
770
771
772
773    /**
774     * {@inheritDoc}
775     */
776    public boolean isAsynchronous() {
777      return impl.getPropertyValue(INSTANCE.getAsynchronousPropertyDefinition());
778    }
779
780
781
782    /**
783     * {@inheritDoc}
784     */
785    public void setAsynchronous(boolean value) {
786      impl.setPropertyValue(INSTANCE.getAsynchronousPropertyDefinition(), value);
787    }
788
789
790
791    /**
792     * {@inheritDoc}
793     */
794    public boolean isAutoFlush() {
795      return impl.getPropertyValue(INSTANCE.getAutoFlushPropertyDefinition());
796    }
797
798
799
800    /**
801     * {@inheritDoc}
802     */
803    public void setAutoFlush(Boolean value) {
804      impl.setPropertyValue(INSTANCE.getAutoFlushPropertyDefinition(), value);
805    }
806
807
808
809    /**
810     * {@inheritDoc}
811     */
812    public long getBufferSize() {
813      return impl.getPropertyValue(INSTANCE.getBufferSizePropertyDefinition());
814    }
815
816
817
818    /**
819     * {@inheritDoc}
820     */
821    public void setBufferSize(Long value) {
822      impl.setPropertyValue(INSTANCE.getBufferSizePropertyDefinition(), value);
823    }
824
825
826
827    /**
828     * {@inheritDoc}
829     */
830    public Boolean isEnabled() {
831      return impl.getPropertyValue(INSTANCE.getEnabledPropertyDefinition());
832    }
833
834
835
836    /**
837     * {@inheritDoc}
838     */
839    public void setEnabled(boolean value) {
840      impl.setPropertyValue(INSTANCE.getEnabledPropertyDefinition(), value);
841    }
842
843
844
845    /**
846     * {@inheritDoc}
847     */
848    public FilteringPolicy getFilteringPolicy() {
849      return impl.getPropertyValue(INSTANCE.getFilteringPolicyPropertyDefinition());
850    }
851
852
853
854    /**
855     * {@inheritDoc}
856     */
857    public void setFilteringPolicy(FilteringPolicy value) {
858      impl.setPropertyValue(INSTANCE.getFilteringPolicyPropertyDefinition(), value);
859    }
860
861
862
863    /**
864     * {@inheritDoc}
865     */
866    public String getJavaClass() {
867      return impl.getPropertyValue(INSTANCE.getJavaClassPropertyDefinition());
868    }
869
870
871
872    /**
873     * {@inheritDoc}
874     */
875    public void setJavaClass(String value) {
876      impl.setPropertyValue(INSTANCE.getJavaClassPropertyDefinition(), value);
877    }
878
879
880
881    /**
882     * {@inheritDoc}
883     */
884    public boolean isLogControlOids() {
885      return impl.getPropertyValue(INSTANCE.getLogControlOidsPropertyDefinition());
886    }
887
888
889
890    /**
891     * {@inheritDoc}
892     */
893    public void setLogControlOids(Boolean value) {
894      impl.setPropertyValue(INSTANCE.getLogControlOidsPropertyDefinition(), value);
895    }
896
897
898
899    /**
900     * {@inheritDoc}
901     */
902    public String getLogFile() {
903      return impl.getPropertyValue(INSTANCE.getLogFilePropertyDefinition());
904    }
905
906
907
908    /**
909     * {@inheritDoc}
910     */
911    public void setLogFile(String value) {
912      impl.setPropertyValue(INSTANCE.getLogFilePropertyDefinition(), value);
913    }
914
915
916
917    /**
918     * {@inheritDoc}
919     */
920    public String getLogFilePermissions() {
921      return impl.getPropertyValue(INSTANCE.getLogFilePermissionsPropertyDefinition());
922    }
923
924
925
926    /**
927     * {@inheritDoc}
928     */
929    public void setLogFilePermissions(String value) {
930      impl.setPropertyValue(INSTANCE.getLogFilePermissionsPropertyDefinition(), value);
931    }
932
933
934
935    /**
936     * {@inheritDoc}
937     */
938    public LogFormat getLogFormat() {
939      return impl.getPropertyValue(INSTANCE.getLogFormatPropertyDefinition());
940    }
941
942
943
944    /**
945     * {@inheritDoc}
946     */
947    public void setLogFormat(LogFormat value) {
948      impl.setPropertyValue(INSTANCE.getLogFormatPropertyDefinition(), value);
949    }
950
951
952
953    /**
954     * {@inheritDoc}
955     */
956    public String getLogRecordTimeFormat() {
957      return impl.getPropertyValue(INSTANCE.getLogRecordTimeFormatPropertyDefinition());
958    }
959
960
961
962    /**
963     * {@inheritDoc}
964     */
965    public void setLogRecordTimeFormat(String value) {
966      impl.setPropertyValue(INSTANCE.getLogRecordTimeFormatPropertyDefinition(), value);
967    }
968
969
970
971    /**
972     * {@inheritDoc}
973     */
974    public int getQueueSize() {
975      return impl.getPropertyValue(INSTANCE.getQueueSizePropertyDefinition());
976    }
977
978
979
980    /**
981     * {@inheritDoc}
982     */
983    public void setQueueSize(Integer value) {
984      impl.setPropertyValue(INSTANCE.getQueueSizePropertyDefinition(), value);
985    }
986
987
988
989    /**
990     * {@inheritDoc}
991     */
992    public SortedSet<String> getRetentionPolicy() {
993      return impl.getPropertyValues(INSTANCE.getRetentionPolicyPropertyDefinition());
994    }
995
996
997
998    /**
999     * {@inheritDoc}
1000     */
1001    public void setRetentionPolicy(Collection<String> values) {
1002      impl.setPropertyValues(INSTANCE.getRetentionPolicyPropertyDefinition(), values);
1003    }
1004
1005
1006
1007    /**
1008     * {@inheritDoc}
1009     */
1010    public SortedSet<String> getRotationPolicy() {
1011      return impl.getPropertyValues(INSTANCE.getRotationPolicyPropertyDefinition());
1012    }
1013
1014
1015
1016    /**
1017     * {@inheritDoc}
1018     */
1019    public void setRotationPolicy(Collection<String> values) {
1020      impl.setPropertyValues(INSTANCE.getRotationPolicyPropertyDefinition(), values);
1021    }
1022
1023
1024
1025    /**
1026     * {@inheritDoc}
1027     */
1028    public boolean isSuppressInternalOperations() {
1029      return impl.getPropertyValue(INSTANCE.getSuppressInternalOperationsPropertyDefinition());
1030    }
1031
1032
1033
1034    /**
1035     * {@inheritDoc}
1036     */
1037    public void setSuppressInternalOperations(Boolean value) {
1038      impl.setPropertyValue(INSTANCE.getSuppressInternalOperationsPropertyDefinition(), value);
1039    }
1040
1041
1042
1043    /**
1044     * {@inheritDoc}
1045     */
1046    public boolean isSuppressSynchronizationOperations() {
1047      return impl.getPropertyValue(INSTANCE.getSuppressSynchronizationOperationsPropertyDefinition());
1048    }
1049
1050
1051
1052    /**
1053     * {@inheritDoc}
1054     */
1055    public void setSuppressSynchronizationOperations(Boolean value) {
1056      impl.setPropertyValue(INSTANCE.getSuppressSynchronizationOperationsPropertyDefinition(), value);
1057    }
1058
1059
1060
1061    /**
1062     * {@inheritDoc}
1063     */
1064    public long getTimeInterval() {
1065      return impl.getPropertyValue(INSTANCE.getTimeIntervalPropertyDefinition());
1066    }
1067
1068
1069
1070    /**
1071     * {@inheritDoc}
1072     */
1073    public void setTimeInterval(Long value) {
1074      impl.setPropertyValue(INSTANCE.getTimeIntervalPropertyDefinition(), value);
1075    }
1076
1077
1078
1079    /**
1080     * {@inheritDoc}
1081     */
1082    public String[] listAccessLogFilteringCriteria() throws ConcurrentModificationException,
1083        LdapException {
1084      return impl.listChildren(INSTANCE.getAccessLogFilteringCriteriaRelationDefinition());
1085    }
1086
1087
1088
1089    /**
1090     * {@inheritDoc}
1091     */
1092    public AccessLogFilteringCriteriaCfgClient getAccessLogFilteringCriteria(String name)
1093        throws DefinitionDecodingException, ManagedObjectDecodingException,
1094        ManagedObjectNotFoundException, ConcurrentModificationException,
1095        LdapException {
1096      return impl.getChild(INSTANCE.getAccessLogFilteringCriteriaRelationDefinition(), name).getConfiguration();
1097    }
1098
1099
1100
1101    /**
1102     * {@inheritDoc}
1103     */
1104    public <M extends AccessLogFilteringCriteriaCfgClient> M createAccessLogFilteringCriteria(
1105        ManagedObjectDefinition<M, ? extends AccessLogFilteringCriteriaCfg> d, String name, Collection<PropertyException> exceptions) throws IllegalManagedObjectNameException {
1106      return impl.createChild(INSTANCE.getAccessLogFilteringCriteriaRelationDefinition(), d, name, exceptions).getConfiguration();
1107    }
1108
1109
1110
1111    /**
1112     * {@inheritDoc}
1113     */
1114    public void removeAccessLogFilteringCriteria(String name)
1115        throws ManagedObjectNotFoundException, ConcurrentModificationException,
1116        OperationRejectedException, LdapException {
1117      impl.removeChild(INSTANCE.getAccessLogFilteringCriteriaRelationDefinition(), name);
1118    }
1119
1120
1121
1122    /**
1123     * {@inheritDoc}
1124     */
1125    public ManagedObjectDefinition<? extends FileBasedAccessLogPublisherCfgClient, ? extends FileBasedAccessLogPublisherCfg> definition() {
1126      return INSTANCE;
1127    }
1128
1129
1130
1131    /**
1132     * {@inheritDoc}
1133     */
1134    public PropertyProvider properties() {
1135      return impl;
1136    }
1137
1138
1139
1140    /**
1141     * {@inheritDoc}
1142     */
1143    public void commit() throws ManagedObjectAlreadyExistsException,
1144        MissingMandatoryPropertiesException, ConcurrentModificationException,
1145        OperationRejectedException, LdapException {
1146      impl.commit();
1147    }
1148
1149  }
1150
1151
1152
1153  /**
1154   * Managed object server implementation.
1155   */
1156  private static class FileBasedAccessLogPublisherCfgServerImpl implements
1157    FileBasedAccessLogPublisherCfg {
1158
1159    // Private implementation.
1160    private ServerManagedObject<? extends FileBasedAccessLogPublisherCfg> impl;
1161
1162    // The value of the "append" property.
1163    private final boolean pAppend;
1164
1165    // The value of the "asynchronous" property.
1166    private final boolean pAsynchronous;
1167
1168    // The value of the "auto-flush" property.
1169    private final boolean pAutoFlush;
1170
1171    // The value of the "buffer-size" property.
1172    private final long pBufferSize;
1173
1174    // The value of the "enabled" property.
1175    private final boolean pEnabled;
1176
1177    // The value of the "filtering-policy" property.
1178    private final FilteringPolicy pFilteringPolicy;
1179
1180    // The value of the "java-class" property.
1181    private final String pJavaClass;
1182
1183    // The value of the "log-control-oids" property.
1184    private final boolean pLogControlOids;
1185
1186    // The value of the "log-file" property.
1187    private final String pLogFile;
1188
1189    // The value of the "log-file-permissions" property.
1190    private final String pLogFilePermissions;
1191
1192    // The value of the "log-format" property.
1193    private final LogFormat pLogFormat;
1194
1195    // The value of the "log-record-time-format" property.
1196    private final String pLogRecordTimeFormat;
1197
1198    // The value of the "queue-size" property.
1199    private final int pQueueSize;
1200
1201    // The value of the "retention-policy" property.
1202    private final SortedSet<String> pRetentionPolicy;
1203
1204    // The value of the "rotation-policy" property.
1205    private final SortedSet<String> pRotationPolicy;
1206
1207    // The value of the "suppress-internal-operations" property.
1208    private final boolean pSuppressInternalOperations;
1209
1210    // The value of the "suppress-synchronization-operations" property.
1211    private final boolean pSuppressSynchronizationOperations;
1212
1213    // The value of the "time-interval" property.
1214    private final long pTimeInterval;
1215
1216
1217
1218    // Private constructor.
1219    private FileBasedAccessLogPublisherCfgServerImpl(ServerManagedObject<? extends FileBasedAccessLogPublisherCfg> impl) {
1220      this.impl = impl;
1221      this.pAppend = impl.getPropertyValue(INSTANCE.getAppendPropertyDefinition());
1222      this.pAsynchronous = impl.getPropertyValue(INSTANCE.getAsynchronousPropertyDefinition());
1223      this.pAutoFlush = impl.getPropertyValue(INSTANCE.getAutoFlushPropertyDefinition());
1224      this.pBufferSize = impl.getPropertyValue(INSTANCE.getBufferSizePropertyDefinition());
1225      this.pEnabled = impl.getPropertyValue(INSTANCE.getEnabledPropertyDefinition());
1226      this.pFilteringPolicy = impl.getPropertyValue(INSTANCE.getFilteringPolicyPropertyDefinition());
1227      this.pJavaClass = impl.getPropertyValue(INSTANCE.getJavaClassPropertyDefinition());
1228      this.pLogControlOids = impl.getPropertyValue(INSTANCE.getLogControlOidsPropertyDefinition());
1229      this.pLogFile = impl.getPropertyValue(INSTANCE.getLogFilePropertyDefinition());
1230      this.pLogFilePermissions = impl.getPropertyValue(INSTANCE.getLogFilePermissionsPropertyDefinition());
1231      this.pLogFormat = impl.getPropertyValue(INSTANCE.getLogFormatPropertyDefinition());
1232      this.pLogRecordTimeFormat = impl.getPropertyValue(INSTANCE.getLogRecordTimeFormatPropertyDefinition());
1233      this.pQueueSize = impl.getPropertyValue(INSTANCE.getQueueSizePropertyDefinition());
1234      this.pRetentionPolicy = impl.getPropertyValues(INSTANCE.getRetentionPolicyPropertyDefinition());
1235      this.pRotationPolicy = impl.getPropertyValues(INSTANCE.getRotationPolicyPropertyDefinition());
1236      this.pSuppressInternalOperations = impl.getPropertyValue(INSTANCE.getSuppressInternalOperationsPropertyDefinition());
1237      this.pSuppressSynchronizationOperations = impl.getPropertyValue(INSTANCE.getSuppressSynchronizationOperationsPropertyDefinition());
1238      this.pTimeInterval = impl.getPropertyValue(INSTANCE.getTimeIntervalPropertyDefinition());
1239    }
1240
1241
1242
1243    /**
1244     * {@inheritDoc}
1245     */
1246    public void addFileBasedAccessChangeListener(
1247        ConfigurationChangeListener<FileBasedAccessLogPublisherCfg> listener) {
1248      impl.registerChangeListener(listener);
1249    }
1250
1251
1252
1253    /**
1254     * {@inheritDoc}
1255     */
1256    public void removeFileBasedAccessChangeListener(
1257        ConfigurationChangeListener<FileBasedAccessLogPublisherCfg> listener) {
1258      impl.deregisterChangeListener(listener);
1259    }
1260    /**
1261     * {@inheritDoc}
1262     */
1263    public void addAccessChangeListener(
1264        ConfigurationChangeListener<AccessLogPublisherCfg> listener) {
1265      impl.registerChangeListener(listener);
1266    }
1267
1268
1269
1270    /**
1271     * {@inheritDoc}
1272     */
1273    public void removeAccessChangeListener(
1274        ConfigurationChangeListener<AccessLogPublisherCfg> listener) {
1275      impl.deregisterChangeListener(listener);
1276    }
1277    /**
1278     * {@inheritDoc}
1279     */
1280    public void addChangeListener(
1281        ConfigurationChangeListener<LogPublisherCfg> listener) {
1282      impl.registerChangeListener(listener);
1283    }
1284
1285
1286
1287    /**
1288     * {@inheritDoc}
1289     */
1290    public void removeChangeListener(
1291        ConfigurationChangeListener<LogPublisherCfg> listener) {
1292      impl.deregisterChangeListener(listener);
1293    }
1294
1295
1296
1297    /**
1298     * {@inheritDoc}
1299     */
1300    public boolean isAppend() {
1301      return pAppend;
1302    }
1303
1304
1305
1306    /**
1307     * {@inheritDoc}
1308     */
1309    public boolean isAsynchronous() {
1310      return pAsynchronous;
1311    }
1312
1313
1314
1315    /**
1316     * {@inheritDoc}
1317     */
1318    public boolean isAutoFlush() {
1319      return pAutoFlush;
1320    }
1321
1322
1323
1324    /**
1325     * {@inheritDoc}
1326     */
1327    public long getBufferSize() {
1328      return pBufferSize;
1329    }
1330
1331
1332
1333    /**
1334     * {@inheritDoc}
1335     */
1336    public boolean isEnabled() {
1337      return pEnabled;
1338    }
1339
1340
1341
1342    /**
1343     * {@inheritDoc}
1344     */
1345    public FilteringPolicy getFilteringPolicy() {
1346      return pFilteringPolicy;
1347    }
1348
1349
1350
1351    /**
1352     * {@inheritDoc}
1353     */
1354    public String getJavaClass() {
1355      return pJavaClass;
1356    }
1357
1358
1359
1360    /**
1361     * {@inheritDoc}
1362     */
1363    public boolean isLogControlOids() {
1364      return pLogControlOids;
1365    }
1366
1367
1368
1369    /**
1370     * {@inheritDoc}
1371     */
1372    public String getLogFile() {
1373      return pLogFile;
1374    }
1375
1376
1377
1378    /**
1379     * {@inheritDoc}
1380     */
1381    public String getLogFilePermissions() {
1382      return pLogFilePermissions;
1383    }
1384
1385
1386
1387    /**
1388     * {@inheritDoc}
1389     */
1390    public LogFormat getLogFormat() {
1391      return pLogFormat;
1392    }
1393
1394
1395
1396    /**
1397     * {@inheritDoc}
1398     */
1399    public String getLogRecordTimeFormat() {
1400      return pLogRecordTimeFormat;
1401    }
1402
1403
1404
1405    /**
1406     * {@inheritDoc}
1407     */
1408    public int getQueueSize() {
1409      return pQueueSize;
1410    }
1411
1412
1413
1414    /**
1415     * {@inheritDoc}
1416     */
1417    public SortedSet<String> getRetentionPolicy() {
1418      return pRetentionPolicy;
1419    }
1420
1421
1422
1423    /**
1424     * {@inheritDoc}
1425     */
1426    public SortedSet<DN> getRetentionPolicyDNs() {
1427      SortedSet<String> values = getRetentionPolicy();
1428      SortedSet<DN> dnValues = new TreeSet<DN>();
1429      for (String value : values) {
1430        DN dn = INSTANCE.getRetentionPolicyPropertyDefinition().getChildDN(value);
1431        dnValues.add(dn);
1432      }
1433      return dnValues;
1434    }
1435
1436
1437
1438    /**
1439     * {@inheritDoc}
1440     */
1441    public SortedSet<String> getRotationPolicy() {
1442      return pRotationPolicy;
1443    }
1444
1445
1446
1447    /**
1448     * {@inheritDoc}
1449     */
1450    public SortedSet<DN> getRotationPolicyDNs() {
1451      SortedSet<String> values = getRotationPolicy();
1452      SortedSet<DN> dnValues = new TreeSet<DN>();
1453      for (String value : values) {
1454        DN dn = INSTANCE.getRotationPolicyPropertyDefinition().getChildDN(value);
1455        dnValues.add(dn);
1456      }
1457      return dnValues;
1458    }
1459
1460
1461
1462    /**
1463     * {@inheritDoc}
1464     */
1465    public boolean isSuppressInternalOperations() {
1466      return pSuppressInternalOperations;
1467    }
1468
1469
1470
1471    /**
1472     * {@inheritDoc}
1473     */
1474    public boolean isSuppressSynchronizationOperations() {
1475      return pSuppressSynchronizationOperations;
1476    }
1477
1478
1479
1480    /**
1481     * {@inheritDoc}
1482     */
1483    public long getTimeInterval() {
1484      return pTimeInterval;
1485    }
1486
1487
1488
1489    /**
1490     * {@inheritDoc}
1491     */
1492    public String[] listAccessLogFilteringCriteria() {
1493      return impl.listChildren(INSTANCE.getAccessLogFilteringCriteriaRelationDefinition());
1494    }
1495
1496
1497
1498    /**
1499     * {@inheritDoc}
1500     */
1501    public AccessLogFilteringCriteriaCfg getAccessLogFilteringCriteria(String name) throws ConfigException {
1502      return impl.getChild(INSTANCE.getAccessLogFilteringCriteriaRelationDefinition(), name).getConfiguration();
1503    }
1504
1505
1506
1507    /**
1508     * {@inheritDoc}
1509     */
1510    public void addAccessLogFilteringCriteriaAddListener(
1511        ConfigurationAddListener<AccessLogFilteringCriteriaCfg> listener) throws ConfigException {
1512      impl.registerAddListener(INSTANCE.getAccessLogFilteringCriteriaRelationDefinition(), listener);
1513    }
1514
1515
1516
1517    /**
1518     * {@inheritDoc}
1519     */
1520    public void removeAccessLogFilteringCriteriaAddListener(
1521        ConfigurationAddListener<AccessLogFilteringCriteriaCfg> listener) {
1522      impl.deregisterAddListener(INSTANCE.getAccessLogFilteringCriteriaRelationDefinition(), listener);
1523    }
1524
1525
1526
1527    /**
1528     * {@inheritDoc}
1529     */
1530    public void addAccessLogFilteringCriteriaDeleteListener(
1531        ConfigurationDeleteListener<AccessLogFilteringCriteriaCfg> listener) throws ConfigException {
1532      impl.registerDeleteListener(INSTANCE.getAccessLogFilteringCriteriaRelationDefinition(), listener);
1533    }
1534
1535
1536
1537    /**
1538     * {@inheritDoc}
1539     */
1540    public void removeAccessLogFilteringCriteriaDeleteListener(
1541        ConfigurationDeleteListener<AccessLogFilteringCriteriaCfg> listener) {
1542      impl.deregisterDeleteListener(INSTANCE.getAccessLogFilteringCriteriaRelationDefinition(), listener);
1543    }
1544
1545
1546
1547    /**
1548     * {@inheritDoc}
1549     */
1550    public Class<? extends FileBasedAccessLogPublisherCfg> configurationClass() {
1551      return FileBasedAccessLogPublisherCfg.class;
1552    }
1553
1554
1555
1556    /**
1557     * {@inheritDoc}
1558     */
1559    public DN dn() {
1560      return impl.getDN();
1561    }
1562
1563  }
1564}