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