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