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}