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