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