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 org.forgerock.opendj.config.AdministratorAction; 033import org.forgerock.opendj.config.BooleanPropertyDefinition; 034import org.forgerock.opendj.config.client.ConcurrentModificationException; 035import org.forgerock.opendj.config.client.ManagedObject; 036import org.forgerock.opendj.config.client.MissingMandatoryPropertiesException; 037import org.forgerock.opendj.config.client.OperationRejectedException; 038import org.forgerock.opendj.config.DNPropertyDefinition; 039import org.forgerock.opendj.config.EnumPropertyDefinition; 040import org.forgerock.opendj.config.IntegerPropertyDefinition; 041import org.forgerock.opendj.config.IPAddressMaskPropertyDefinition; 042import org.forgerock.opendj.config.ManagedObjectAlreadyExistsException; 043import org.forgerock.opendj.config.ManagedObjectDefinition; 044import org.forgerock.opendj.config.PropertyOption; 045import org.forgerock.opendj.config.PropertyProvider; 046import org.forgerock.opendj.config.server.ConfigurationChangeListener; 047import org.forgerock.opendj.config.server.ServerManagedObject; 048import org.forgerock.opendj.config.StringPropertyDefinition; 049import org.forgerock.opendj.config.Tag; 050import org.forgerock.opendj.config.TopCfgDefn; 051import org.forgerock.opendj.config.UndefinedDefaultBehaviorProvider; 052import org.forgerock.opendj.ldap.AddressMask; 053import org.forgerock.opendj.ldap.DN; 054import org.forgerock.opendj.ldap.LdapException; 055import org.forgerock.opendj.server.config.client.AccessLogFilteringCriteriaCfgClient; 056import org.forgerock.opendj.server.config.server.AccessLogFilteringCriteriaCfg; 057 058 059 060/** 061 * An interface for querying the Access Log Filtering Criteria managed 062 * object definition meta information. 063 * <p> 064 * A set of rules which together determine whether a log record should 065 * be logged or not. 066 */ 067public final class AccessLogFilteringCriteriaCfgDefn extends ManagedObjectDefinition<AccessLogFilteringCriteriaCfgClient, AccessLogFilteringCriteriaCfg> { 068 069 // The singleton configuration definition instance. 070 private static final AccessLogFilteringCriteriaCfgDefn INSTANCE = new AccessLogFilteringCriteriaCfgDefn(); 071 072 073 074 /** 075 * Defines the set of permissable values for the "log-record-type" property. 076 * <p> 077 * Filters log records based on their type. 078 */ 079 public static enum LogRecordType { 080 081 /** 082 * Abandon operations 083 */ 084 ABANDON("abandon"), 085 086 087 088 /** 089 * Add operations 090 */ 091 ADD("add"), 092 093 094 095 /** 096 * Bind operations 097 */ 098 BIND("bind"), 099 100 101 102 /** 103 * Compare operations 104 */ 105 COMPARE("compare"), 106 107 108 109 /** 110 * Client connections 111 */ 112 CONNECT("connect"), 113 114 115 116 /** 117 * Delete operations 118 */ 119 DELETE("delete"), 120 121 122 123 /** 124 * Client disconnections 125 */ 126 DISCONNECT("disconnect"), 127 128 129 130 /** 131 * Extended operations 132 */ 133 EXTENDED("extended"), 134 135 136 137 /** 138 * Modify operations 139 */ 140 MODIFY("modify"), 141 142 143 144 /** 145 * Rename operations 146 */ 147 RENAME("rename"), 148 149 150 151 /** 152 * Search operations 153 */ 154 SEARCH("search"), 155 156 157 158 /** 159 * Unbind operations 160 */ 161 UNBIND("unbind"); 162 163 164 165 // String representation of the value. 166 private final String name; 167 168 169 170 // Private constructor. 171 private LogRecordType(String name) { this.name = name; } 172 173 174 175 /** 176 * {@inheritDoc} 177 */ 178 public String toString() { return name; } 179 180 } 181 182 183 184 // The "connection-client-address-equal-to" property definition. 185 private static final IPAddressMaskPropertyDefinition PD_CONNECTION_CLIENT_ADDRESS_EQUAL_TO; 186 187 188 189 // The "connection-client-address-not-equal-to" property definition. 190 private static final IPAddressMaskPropertyDefinition PD_CONNECTION_CLIENT_ADDRESS_NOT_EQUAL_TO; 191 192 193 194 // The "connection-port-equal-to" property definition. 195 private static final IntegerPropertyDefinition PD_CONNECTION_PORT_EQUAL_TO; 196 197 198 199 // The "connection-protocol-equal-to" property definition. 200 private static final StringPropertyDefinition PD_CONNECTION_PROTOCOL_EQUAL_TO; 201 202 203 204 // The "log-record-type" property definition. 205 private static final EnumPropertyDefinition<LogRecordType> PD_LOG_RECORD_TYPE; 206 207 208 209 // The "request-target-dn-equal-to" property definition. 210 private static final StringPropertyDefinition PD_REQUEST_TARGET_DN_EQUAL_TO; 211 212 213 214 // The "request-target-dn-not-equal-to" property definition. 215 private static final StringPropertyDefinition PD_REQUEST_TARGET_DN_NOT_EQUAL_TO; 216 217 218 219 // The "response-etime-greater-than" property definition. 220 private static final IntegerPropertyDefinition PD_RESPONSE_ETIME_GREATER_THAN; 221 222 223 224 // The "response-etime-less-than" property definition. 225 private static final IntegerPropertyDefinition PD_RESPONSE_ETIME_LESS_THAN; 226 227 228 229 // The "response-result-code-equal-to" property definition. 230 private static final IntegerPropertyDefinition PD_RESPONSE_RESULT_CODE_EQUAL_TO; 231 232 233 234 // The "response-result-code-not-equal-to" property definition. 235 private static final IntegerPropertyDefinition PD_RESPONSE_RESULT_CODE_NOT_EQUAL_TO; 236 237 238 239 // The "search-response-is-indexed" property definition. 240 private static final BooleanPropertyDefinition PD_SEARCH_RESPONSE_IS_INDEXED; 241 242 243 244 // The "search-response-nentries-greater-than" property definition. 245 private static final IntegerPropertyDefinition PD_SEARCH_RESPONSE_NENTRIES_GREATER_THAN; 246 247 248 249 // The "search-response-nentries-less-than" property definition. 250 private static final IntegerPropertyDefinition PD_SEARCH_RESPONSE_NENTRIES_LESS_THAN; 251 252 253 254 // The "user-dn-equal-to" property definition. 255 private static final StringPropertyDefinition PD_USER_DN_EQUAL_TO; 256 257 258 259 // The "user-dn-not-equal-to" property definition. 260 private static final StringPropertyDefinition PD_USER_DN_NOT_EQUAL_TO; 261 262 263 264 // The "user-is-member-of" property definition. 265 private static final DNPropertyDefinition PD_USER_IS_MEMBER_OF; 266 267 268 269 // The "user-is-not-member-of" property definition. 270 private static final DNPropertyDefinition PD_USER_IS_NOT_MEMBER_OF; 271 272 273 274 // Build the "connection-client-address-equal-to" property definition. 275 static { 276 IPAddressMaskPropertyDefinition.Builder builder = IPAddressMaskPropertyDefinition.createBuilder(INSTANCE, "connection-client-address-equal-to"); 277 builder.setOption(PropertyOption.MULTI_VALUED); 278 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "connection-client-address-equal-to")); 279 builder.setDefaultBehaviorProvider(new UndefinedDefaultBehaviorProvider<AddressMask>()); 280 PD_CONNECTION_CLIENT_ADDRESS_EQUAL_TO = builder.getInstance(); 281 INSTANCE.registerPropertyDefinition(PD_CONNECTION_CLIENT_ADDRESS_EQUAL_TO); 282 } 283 284 285 286 // Build the "connection-client-address-not-equal-to" property definition. 287 static { 288 IPAddressMaskPropertyDefinition.Builder builder = IPAddressMaskPropertyDefinition.createBuilder(INSTANCE, "connection-client-address-not-equal-to"); 289 builder.setOption(PropertyOption.MULTI_VALUED); 290 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "connection-client-address-not-equal-to")); 291 builder.setDefaultBehaviorProvider(new UndefinedDefaultBehaviorProvider<AddressMask>()); 292 PD_CONNECTION_CLIENT_ADDRESS_NOT_EQUAL_TO = builder.getInstance(); 293 INSTANCE.registerPropertyDefinition(PD_CONNECTION_CLIENT_ADDRESS_NOT_EQUAL_TO); 294 } 295 296 297 298 // Build the "connection-port-equal-to" property definition. 299 static { 300 IntegerPropertyDefinition.Builder builder = IntegerPropertyDefinition.createBuilder(INSTANCE, "connection-port-equal-to"); 301 builder.setOption(PropertyOption.MULTI_VALUED); 302 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "connection-port-equal-to")); 303 builder.setDefaultBehaviorProvider(new UndefinedDefaultBehaviorProvider<Integer>()); 304 builder.setUpperLimit(65535); 305 builder.setLowerLimit(1); 306 PD_CONNECTION_PORT_EQUAL_TO = builder.getInstance(); 307 INSTANCE.registerPropertyDefinition(PD_CONNECTION_PORT_EQUAL_TO); 308 } 309 310 311 312 // Build the "connection-protocol-equal-to" property definition. 313 static { 314 StringPropertyDefinition.Builder builder = StringPropertyDefinition.createBuilder(INSTANCE, "connection-protocol-equal-to"); 315 builder.setOption(PropertyOption.MULTI_VALUED); 316 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "connection-protocol-equal-to")); 317 builder.setDefaultBehaviorProvider(new UndefinedDefaultBehaviorProvider<String>()); 318 builder.setPattern("[a-zA-Z0-9]+", "NAME"); 319 PD_CONNECTION_PROTOCOL_EQUAL_TO = builder.getInstance(); 320 INSTANCE.registerPropertyDefinition(PD_CONNECTION_PROTOCOL_EQUAL_TO); 321 } 322 323 324 325 // Build the "log-record-type" property definition. 326 static { 327 EnumPropertyDefinition.Builder<LogRecordType> builder = EnumPropertyDefinition.createBuilder(INSTANCE, "log-record-type"); 328 builder.setOption(PropertyOption.MULTI_VALUED); 329 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "log-record-type")); 330 builder.setDefaultBehaviorProvider(new UndefinedDefaultBehaviorProvider<LogRecordType>()); 331 builder.setEnumClass(LogRecordType.class); 332 PD_LOG_RECORD_TYPE = builder.getInstance(); 333 INSTANCE.registerPropertyDefinition(PD_LOG_RECORD_TYPE); 334 } 335 336 337 338 // Build the "request-target-dn-equal-to" property definition. 339 static { 340 StringPropertyDefinition.Builder builder = StringPropertyDefinition.createBuilder(INSTANCE, "request-target-dn-equal-to"); 341 builder.setOption(PropertyOption.MULTI_VALUED); 342 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "request-target-dn-equal-to")); 343 builder.setDefaultBehaviorProvider(new UndefinedDefaultBehaviorProvider<String>()); 344 PD_REQUEST_TARGET_DN_EQUAL_TO = builder.getInstance(); 345 INSTANCE.registerPropertyDefinition(PD_REQUEST_TARGET_DN_EQUAL_TO); 346 } 347 348 349 350 // Build the "request-target-dn-not-equal-to" property definition. 351 static { 352 StringPropertyDefinition.Builder builder = StringPropertyDefinition.createBuilder(INSTANCE, "request-target-dn-not-equal-to"); 353 builder.setOption(PropertyOption.MULTI_VALUED); 354 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "request-target-dn-not-equal-to")); 355 builder.setDefaultBehaviorProvider(new UndefinedDefaultBehaviorProvider<String>()); 356 PD_REQUEST_TARGET_DN_NOT_EQUAL_TO = builder.getInstance(); 357 INSTANCE.registerPropertyDefinition(PD_REQUEST_TARGET_DN_NOT_EQUAL_TO); 358 } 359 360 361 362 // Build the "response-etime-greater-than" property definition. 363 static { 364 IntegerPropertyDefinition.Builder builder = IntegerPropertyDefinition.createBuilder(INSTANCE, "response-etime-greater-than"); 365 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "response-etime-greater-than")); 366 builder.setDefaultBehaviorProvider(new UndefinedDefaultBehaviorProvider<Integer>()); 367 PD_RESPONSE_ETIME_GREATER_THAN = builder.getInstance(); 368 INSTANCE.registerPropertyDefinition(PD_RESPONSE_ETIME_GREATER_THAN); 369 } 370 371 372 373 // Build the "response-etime-less-than" property definition. 374 static { 375 IntegerPropertyDefinition.Builder builder = IntegerPropertyDefinition.createBuilder(INSTANCE, "response-etime-less-than"); 376 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "response-etime-less-than")); 377 builder.setDefaultBehaviorProvider(new UndefinedDefaultBehaviorProvider<Integer>()); 378 PD_RESPONSE_ETIME_LESS_THAN = builder.getInstance(); 379 INSTANCE.registerPropertyDefinition(PD_RESPONSE_ETIME_LESS_THAN); 380 } 381 382 383 384 // Build the "response-result-code-equal-to" property definition. 385 static { 386 IntegerPropertyDefinition.Builder builder = IntegerPropertyDefinition.createBuilder(INSTANCE, "response-result-code-equal-to"); 387 builder.setOption(PropertyOption.MULTI_VALUED); 388 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "response-result-code-equal-to")); 389 builder.setDefaultBehaviorProvider(new UndefinedDefaultBehaviorProvider<Integer>()); 390 PD_RESPONSE_RESULT_CODE_EQUAL_TO = builder.getInstance(); 391 INSTANCE.registerPropertyDefinition(PD_RESPONSE_RESULT_CODE_EQUAL_TO); 392 } 393 394 395 396 // Build the "response-result-code-not-equal-to" property definition. 397 static { 398 IntegerPropertyDefinition.Builder builder = IntegerPropertyDefinition.createBuilder(INSTANCE, "response-result-code-not-equal-to"); 399 builder.setOption(PropertyOption.MULTI_VALUED); 400 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "response-result-code-not-equal-to")); 401 builder.setDefaultBehaviorProvider(new UndefinedDefaultBehaviorProvider<Integer>()); 402 PD_RESPONSE_RESULT_CODE_NOT_EQUAL_TO = builder.getInstance(); 403 INSTANCE.registerPropertyDefinition(PD_RESPONSE_RESULT_CODE_NOT_EQUAL_TO); 404 } 405 406 407 408 // Build the "search-response-is-indexed" property definition. 409 static { 410 BooleanPropertyDefinition.Builder builder = BooleanPropertyDefinition.createBuilder(INSTANCE, "search-response-is-indexed"); 411 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "search-response-is-indexed")); 412 builder.setDefaultBehaviorProvider(new UndefinedDefaultBehaviorProvider<Boolean>()); 413 PD_SEARCH_RESPONSE_IS_INDEXED = builder.getInstance(); 414 INSTANCE.registerPropertyDefinition(PD_SEARCH_RESPONSE_IS_INDEXED); 415 } 416 417 418 419 // Build the "search-response-nentries-greater-than" property definition. 420 static { 421 IntegerPropertyDefinition.Builder builder = IntegerPropertyDefinition.createBuilder(INSTANCE, "search-response-nentries-greater-than"); 422 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "search-response-nentries-greater-than")); 423 builder.setDefaultBehaviorProvider(new UndefinedDefaultBehaviorProvider<Integer>()); 424 PD_SEARCH_RESPONSE_NENTRIES_GREATER_THAN = builder.getInstance(); 425 INSTANCE.registerPropertyDefinition(PD_SEARCH_RESPONSE_NENTRIES_GREATER_THAN); 426 } 427 428 429 430 // Build the "search-response-nentries-less-than" property definition. 431 static { 432 IntegerPropertyDefinition.Builder builder = IntegerPropertyDefinition.createBuilder(INSTANCE, "search-response-nentries-less-than"); 433 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "search-response-nentries-less-than")); 434 builder.setDefaultBehaviorProvider(new UndefinedDefaultBehaviorProvider<Integer>()); 435 PD_SEARCH_RESPONSE_NENTRIES_LESS_THAN = builder.getInstance(); 436 INSTANCE.registerPropertyDefinition(PD_SEARCH_RESPONSE_NENTRIES_LESS_THAN); 437 } 438 439 440 441 // Build the "user-dn-equal-to" property definition. 442 static { 443 StringPropertyDefinition.Builder builder = StringPropertyDefinition.createBuilder(INSTANCE, "user-dn-equal-to"); 444 builder.setOption(PropertyOption.MULTI_VALUED); 445 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "user-dn-equal-to")); 446 builder.setDefaultBehaviorProvider(new UndefinedDefaultBehaviorProvider<String>()); 447 PD_USER_DN_EQUAL_TO = builder.getInstance(); 448 INSTANCE.registerPropertyDefinition(PD_USER_DN_EQUAL_TO); 449 } 450 451 452 453 // Build the "user-dn-not-equal-to" property definition. 454 static { 455 StringPropertyDefinition.Builder builder = StringPropertyDefinition.createBuilder(INSTANCE, "user-dn-not-equal-to"); 456 builder.setOption(PropertyOption.MULTI_VALUED); 457 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "user-dn-not-equal-to")); 458 builder.setDefaultBehaviorProvider(new UndefinedDefaultBehaviorProvider<String>()); 459 PD_USER_DN_NOT_EQUAL_TO = builder.getInstance(); 460 INSTANCE.registerPropertyDefinition(PD_USER_DN_NOT_EQUAL_TO); 461 } 462 463 464 465 // Build the "user-is-member-of" property definition. 466 static { 467 DNPropertyDefinition.Builder builder = DNPropertyDefinition.createBuilder(INSTANCE, "user-is-member-of"); 468 builder.setOption(PropertyOption.MULTI_VALUED); 469 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "user-is-member-of")); 470 builder.setDefaultBehaviorProvider(new UndefinedDefaultBehaviorProvider<DN>()); 471 PD_USER_IS_MEMBER_OF = builder.getInstance(); 472 INSTANCE.registerPropertyDefinition(PD_USER_IS_MEMBER_OF); 473 } 474 475 476 477 // Build the "user-is-not-member-of" property definition. 478 static { 479 DNPropertyDefinition.Builder builder = DNPropertyDefinition.createBuilder(INSTANCE, "user-is-not-member-of"); 480 builder.setOption(PropertyOption.MULTI_VALUED); 481 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "user-is-not-member-of")); 482 builder.setDefaultBehaviorProvider(new UndefinedDefaultBehaviorProvider<DN>()); 483 PD_USER_IS_NOT_MEMBER_OF = builder.getInstance(); 484 INSTANCE.registerPropertyDefinition(PD_USER_IS_NOT_MEMBER_OF); 485 } 486 487 488 489 // Register the tags associated with this managed object definition. 490 static { 491 INSTANCE.registerTag(Tag.valueOf("logging")); 492 } 493 494 495 496 /** 497 * Get the Access Log Filtering Criteria configuration definition 498 * singleton. 499 * 500 * @return Returns the Access Log Filtering Criteria configuration 501 * definition singleton. 502 */ 503 public static AccessLogFilteringCriteriaCfgDefn getInstance() { 504 return INSTANCE; 505 } 506 507 508 509 /** 510 * Private constructor. 511 */ 512 private AccessLogFilteringCriteriaCfgDefn() { 513 super("access-log-filtering-criteria", TopCfgDefn.getInstance()); 514 } 515 516 517 518 /** 519 * {@inheritDoc} 520 */ 521 public AccessLogFilteringCriteriaCfgClient createClientConfiguration( 522 ManagedObject<? extends AccessLogFilteringCriteriaCfgClient> impl) { 523 return new AccessLogFilteringCriteriaCfgClientImpl(impl); 524 } 525 526 527 528 /** 529 * {@inheritDoc} 530 */ 531 public AccessLogFilteringCriteriaCfg createServerConfiguration( 532 ServerManagedObject<? extends AccessLogFilteringCriteriaCfg> impl) { 533 return new AccessLogFilteringCriteriaCfgServerImpl(impl); 534 } 535 536 537 538 /** 539 * {@inheritDoc} 540 */ 541 public Class<AccessLogFilteringCriteriaCfg> getServerConfigurationClass() { 542 return AccessLogFilteringCriteriaCfg.class; 543 } 544 545 546 547 /** 548 * Get the "connection-client-address-equal-to" property definition. 549 * <p> 550 * Filters log records associated with connections which match at 551 * least one of the specified client host names or address masks. 552 * <p> 553 * Valid values include a host name, a fully qualified domain name, 554 * a domain name, an IP address, or a subnetwork with subnetwork 555 * mask. 556 * 557 * @return Returns the "connection-client-address-equal-to" property definition. 558 */ 559 public IPAddressMaskPropertyDefinition getConnectionClientAddressEqualToPropertyDefinition() { 560 return PD_CONNECTION_CLIENT_ADDRESS_EQUAL_TO; 561 } 562 563 564 565 /** 566 * Get the "connection-client-address-not-equal-to" property definition. 567 * <p> 568 * Filters log records associated with connections which do not 569 * match any of the specified client host names or address masks. 570 * <p> 571 * Valid values include a host name, a fully qualified domain name, 572 * a domain name, an IP address, or a subnetwork with subnetwork 573 * mask. 574 * 575 * @return Returns the "connection-client-address-not-equal-to" property definition. 576 */ 577 public IPAddressMaskPropertyDefinition getConnectionClientAddressNotEqualToPropertyDefinition() { 578 return PD_CONNECTION_CLIENT_ADDRESS_NOT_EQUAL_TO; 579 } 580 581 582 583 /** 584 * Get the "connection-port-equal-to" property definition. 585 * <p> 586 * Filters log records associated with connections to any of the 587 * specified listener port numbers. 588 * 589 * @return Returns the "connection-port-equal-to" property definition. 590 */ 591 public IntegerPropertyDefinition getConnectionPortEqualToPropertyDefinition() { 592 return PD_CONNECTION_PORT_EQUAL_TO; 593 } 594 595 596 597 /** 598 * Get the "connection-protocol-equal-to" property definition. 599 * <p> 600 * Filters log records associated with connections which match any 601 * of the specified protocols. 602 * <p> 603 * Typical values include "ldap", "ldaps", or "jmx". 604 * 605 * @return Returns the "connection-protocol-equal-to" property definition. 606 */ 607 public StringPropertyDefinition getConnectionProtocolEqualToPropertyDefinition() { 608 return PD_CONNECTION_PROTOCOL_EQUAL_TO; 609 } 610 611 612 613 /** 614 * Get the "log-record-type" property definition. 615 * <p> 616 * Filters log records based on their type. 617 * 618 * @return Returns the "log-record-type" property definition. 619 */ 620 public EnumPropertyDefinition<LogRecordType> getLogRecordTypePropertyDefinition() { 621 return PD_LOG_RECORD_TYPE; 622 } 623 624 625 626 /** 627 * Get the "request-target-dn-equal-to" property definition. 628 * <p> 629 * Filters operation log records associated with operations which 630 * target entries matching at least one of the specified DN patterns. 631 * <p> 632 * Valid DN filters are strings composed of zero or more wildcards. 633 * A double wildcard ** replaces one or more RDN components (as in 634 * uid=dmiller,**,dc=example,dc=com). A simple wildcard * replaces 635 * either a whole RDN, or a whole type, or a value substring (as in 636 * uid=bj*,ou=people,dc=example,dc=com). 637 * 638 * @return Returns the "request-target-dn-equal-to" property definition. 639 */ 640 public StringPropertyDefinition getRequestTargetDNEqualToPropertyDefinition() { 641 return PD_REQUEST_TARGET_DN_EQUAL_TO; 642 } 643 644 645 646 /** 647 * Get the "request-target-dn-not-equal-to" property definition. 648 * <p> 649 * Filters operation log records associated with operations which 650 * target entries matching none of the specified DN patterns. 651 * <p> 652 * Valid DN filters are strings composed of zero or more wildcards. 653 * A double wildcard ** replaces one or more RDN components (as in 654 * uid=dmiller,**,dc=example,dc=com). A simple wildcard * replaces 655 * either a whole RDN, or a whole type, or a value substring (as in 656 * uid=bj*,ou=people,dc=example,dc=com). 657 * 658 * @return Returns the "request-target-dn-not-equal-to" property definition. 659 */ 660 public StringPropertyDefinition getRequestTargetDNNotEqualToPropertyDefinition() { 661 return PD_REQUEST_TARGET_DN_NOT_EQUAL_TO; 662 } 663 664 665 666 /** 667 * Get the "response-etime-greater-than" property definition. 668 * <p> 669 * Filters operation response log records associated with operations 670 * which took longer than the specified number of milli-seconds to 671 * complete. 672 * <p> 673 * It is recommended to only use this criteria in conjunction with 674 * the "combined" output mode of the access logger, since this filter 675 * criteria is only applied to response log messages. 676 * 677 * @return Returns the "response-etime-greater-than" property definition. 678 */ 679 public IntegerPropertyDefinition getResponseEtimeGreaterThanPropertyDefinition() { 680 return PD_RESPONSE_ETIME_GREATER_THAN; 681 } 682 683 684 685 /** 686 * Get the "response-etime-less-than" property definition. 687 * <p> 688 * Filters operation response log records associated with operations 689 * which took less than the specified number of milli-seconds to 690 * complete. 691 * <p> 692 * It is recommended to only use this criteria in conjunction with 693 * the "combined" output mode of the access logger, since this filter 694 * criteria is only applied to response log messages. 695 * 696 * @return Returns the "response-etime-less-than" property definition. 697 */ 698 public IntegerPropertyDefinition getResponseEtimeLessThanPropertyDefinition() { 699 return PD_RESPONSE_ETIME_LESS_THAN; 700 } 701 702 703 704 /** 705 * Get the "response-result-code-equal-to" property definition. 706 * <p> 707 * Filters operation response log records associated with operations 708 * which include any of the specified result codes. 709 * <p> 710 * It is recommended to only use this criteria in conjunction with 711 * the "combined" output mode of the access logger, since this filter 712 * criteria is only applied to response log messages. 713 * 714 * @return Returns the "response-result-code-equal-to" property definition. 715 */ 716 public IntegerPropertyDefinition getResponseResultCodeEqualToPropertyDefinition() { 717 return PD_RESPONSE_RESULT_CODE_EQUAL_TO; 718 } 719 720 721 722 /** 723 * Get the "response-result-code-not-equal-to" property definition. 724 * <p> 725 * Filters operation response log records associated with operations 726 * which do not include any of the specified result codes. 727 * <p> 728 * It is recommended to only use this criteria in conjunction with 729 * the "combined" output mode of the access logger, since this filter 730 * criteria is only applied to response log messages. 731 * 732 * @return Returns the "response-result-code-not-equal-to" property definition. 733 */ 734 public IntegerPropertyDefinition getResponseResultCodeNotEqualToPropertyDefinition() { 735 return PD_RESPONSE_RESULT_CODE_NOT_EQUAL_TO; 736 } 737 738 739 740 /** 741 * Get the "search-response-is-indexed" property definition. 742 * <p> 743 * Filters search operation response log records associated with 744 * searches which were either indexed or unindexed. 745 * <p> 746 * It is recommended to only use this criteria in conjunction with 747 * the "combined" output mode of the access logger, since this filter 748 * criteria is only applied to response log messages. 749 * 750 * @return Returns the "search-response-is-indexed" property definition. 751 */ 752 public BooleanPropertyDefinition getSearchResponseIsIndexedPropertyDefinition() { 753 return PD_SEARCH_RESPONSE_IS_INDEXED; 754 } 755 756 757 758 /** 759 * Get the "search-response-nentries-greater-than" property definition. 760 * <p> 761 * Filters search operation response log records associated with 762 * searches which returned more than the specified number of entries. 763 * <p> 764 * It is recommended to only use this criteria in conjunction with 765 * the "combined" output mode of the access logger, since this filter 766 * criteria is only applied to response log messages. 767 * 768 * @return Returns the "search-response-nentries-greater-than" property definition. 769 */ 770 public IntegerPropertyDefinition getSearchResponseNentriesGreaterThanPropertyDefinition() { 771 return PD_SEARCH_RESPONSE_NENTRIES_GREATER_THAN; 772 } 773 774 775 776 /** 777 * Get the "search-response-nentries-less-than" property definition. 778 * <p> 779 * Filters search operation response log records associated with 780 * searches which returned less than the specified number of entries. 781 * <p> 782 * It is recommended to only use this criteria in conjunction with 783 * the "combined" output mode of the access logger, since this filter 784 * criteria is only applied to response log messages. 785 * 786 * @return Returns the "search-response-nentries-less-than" property definition. 787 */ 788 public IntegerPropertyDefinition getSearchResponseNentriesLessThanPropertyDefinition() { 789 return PD_SEARCH_RESPONSE_NENTRIES_LESS_THAN; 790 } 791 792 793 794 /** 795 * Get the "user-dn-equal-to" property definition. 796 * <p> 797 * Filters log records associated with users matching at least one 798 * of the specified DN patterns. 799 * <p> 800 * Valid DN filters are strings composed of zero or more wildcards. 801 * A double wildcard ** replaces one or more RDN components (as in 802 * uid=dmiller,**,dc=example,dc=com). A simple wildcard * replaces 803 * either a whole RDN, or a whole type, or a value substring (as in 804 * uid=bj*,ou=people,dc=example,dc=com). 805 * 806 * @return Returns the "user-dn-equal-to" property definition. 807 */ 808 public StringPropertyDefinition getUserDNEqualToPropertyDefinition() { 809 return PD_USER_DN_EQUAL_TO; 810 } 811 812 813 814 /** 815 * Get the "user-dn-not-equal-to" property definition. 816 * <p> 817 * Filters log records associated with users which do not match any 818 * of the specified DN patterns. 819 * <p> 820 * Valid DN filters are strings composed of zero or more wildcards. 821 * A double wildcard ** replaces one or more RDN components (as in 822 * uid=dmiller,**,dc=example,dc=com). A simple wildcard * replaces 823 * either a whole RDN, or a whole type, or a value substring (as in 824 * uid=bj*,ou=people,dc=example,dc=com). 825 * 826 * @return Returns the "user-dn-not-equal-to" property definition. 827 */ 828 public StringPropertyDefinition getUserDNNotEqualToPropertyDefinition() { 829 return PD_USER_DN_NOT_EQUAL_TO; 830 } 831 832 833 834 /** 835 * Get the "user-is-member-of" property definition. 836 * <p> 837 * Filters log records associated with users which are members of at 838 * least one of the specified groups. 839 * 840 * @return Returns the "user-is-member-of" property definition. 841 */ 842 public DNPropertyDefinition getUserIsMemberOfPropertyDefinition() { 843 return PD_USER_IS_MEMBER_OF; 844 } 845 846 847 848 /** 849 * Get the "user-is-not-member-of" property definition. 850 * <p> 851 * Filters log records associated with users which are not members 852 * of any of the specified groups. 853 * 854 * @return Returns the "user-is-not-member-of" property definition. 855 */ 856 public DNPropertyDefinition getUserIsNotMemberOfPropertyDefinition() { 857 return PD_USER_IS_NOT_MEMBER_OF; 858 } 859 860 861 862 /** 863 * Managed object client implementation. 864 */ 865 private static class AccessLogFilteringCriteriaCfgClientImpl implements 866 AccessLogFilteringCriteriaCfgClient { 867 868 // Private implementation. 869 private ManagedObject<? extends AccessLogFilteringCriteriaCfgClient> impl; 870 871 872 873 // Private constructor. 874 private AccessLogFilteringCriteriaCfgClientImpl( 875 ManagedObject<? extends AccessLogFilteringCriteriaCfgClient> impl) { 876 this.impl = impl; 877 } 878 879 880 881 /** 882 * {@inheritDoc} 883 */ 884 public SortedSet<AddressMask> getConnectionClientAddressEqualTo() { 885 return impl.getPropertyValues(INSTANCE.getConnectionClientAddressEqualToPropertyDefinition()); 886 } 887 888 889 890 /** 891 * {@inheritDoc} 892 */ 893 public void setConnectionClientAddressEqualTo(Collection<AddressMask> values) { 894 impl.setPropertyValues(INSTANCE.getConnectionClientAddressEqualToPropertyDefinition(), values); 895 } 896 897 898 899 /** 900 * {@inheritDoc} 901 */ 902 public SortedSet<AddressMask> getConnectionClientAddressNotEqualTo() { 903 return impl.getPropertyValues(INSTANCE.getConnectionClientAddressNotEqualToPropertyDefinition()); 904 } 905 906 907 908 /** 909 * {@inheritDoc} 910 */ 911 public void setConnectionClientAddressNotEqualTo(Collection<AddressMask> values) { 912 impl.setPropertyValues(INSTANCE.getConnectionClientAddressNotEqualToPropertyDefinition(), values); 913 } 914 915 916 917 /** 918 * {@inheritDoc} 919 */ 920 public SortedSet<Integer> getConnectionPortEqualTo() { 921 return impl.getPropertyValues(INSTANCE.getConnectionPortEqualToPropertyDefinition()); 922 } 923 924 925 926 /** 927 * {@inheritDoc} 928 */ 929 public void setConnectionPortEqualTo(Collection<Integer> values) { 930 impl.setPropertyValues(INSTANCE.getConnectionPortEqualToPropertyDefinition(), values); 931 } 932 933 934 935 /** 936 * {@inheritDoc} 937 */ 938 public SortedSet<String> getConnectionProtocolEqualTo() { 939 return impl.getPropertyValues(INSTANCE.getConnectionProtocolEqualToPropertyDefinition()); 940 } 941 942 943 944 /** 945 * {@inheritDoc} 946 */ 947 public void setConnectionProtocolEqualTo(Collection<String> values) { 948 impl.setPropertyValues(INSTANCE.getConnectionProtocolEqualToPropertyDefinition(), values); 949 } 950 951 952 953 /** 954 * {@inheritDoc} 955 */ 956 public SortedSet<LogRecordType> getLogRecordType() { 957 return impl.getPropertyValues(INSTANCE.getLogRecordTypePropertyDefinition()); 958 } 959 960 961 962 /** 963 * {@inheritDoc} 964 */ 965 public void setLogRecordType(Collection<LogRecordType> values) { 966 impl.setPropertyValues(INSTANCE.getLogRecordTypePropertyDefinition(), values); 967 } 968 969 970 971 /** 972 * {@inheritDoc} 973 */ 974 public SortedSet<String> getRequestTargetDNEqualTo() { 975 return impl.getPropertyValues(INSTANCE.getRequestTargetDNEqualToPropertyDefinition()); 976 } 977 978 979 980 /** 981 * {@inheritDoc} 982 */ 983 public void setRequestTargetDNEqualTo(Collection<String> values) { 984 impl.setPropertyValues(INSTANCE.getRequestTargetDNEqualToPropertyDefinition(), values); 985 } 986 987 988 989 /** 990 * {@inheritDoc} 991 */ 992 public SortedSet<String> getRequestTargetDNNotEqualTo() { 993 return impl.getPropertyValues(INSTANCE.getRequestTargetDNNotEqualToPropertyDefinition()); 994 } 995 996 997 998 /** 999 * {@inheritDoc} 1000 */ 1001 public void setRequestTargetDNNotEqualTo(Collection<String> values) { 1002 impl.setPropertyValues(INSTANCE.getRequestTargetDNNotEqualToPropertyDefinition(), values); 1003 } 1004 1005 1006 1007 /** 1008 * {@inheritDoc} 1009 */ 1010 public Integer getResponseEtimeGreaterThan() { 1011 return impl.getPropertyValue(INSTANCE.getResponseEtimeGreaterThanPropertyDefinition()); 1012 } 1013 1014 1015 1016 /** 1017 * {@inheritDoc} 1018 */ 1019 public void setResponseEtimeGreaterThan(Integer value) { 1020 impl.setPropertyValue(INSTANCE.getResponseEtimeGreaterThanPropertyDefinition(), value); 1021 } 1022 1023 1024 1025 /** 1026 * {@inheritDoc} 1027 */ 1028 public Integer getResponseEtimeLessThan() { 1029 return impl.getPropertyValue(INSTANCE.getResponseEtimeLessThanPropertyDefinition()); 1030 } 1031 1032 1033 1034 /** 1035 * {@inheritDoc} 1036 */ 1037 public void setResponseEtimeLessThan(Integer value) { 1038 impl.setPropertyValue(INSTANCE.getResponseEtimeLessThanPropertyDefinition(), value); 1039 } 1040 1041 1042 1043 /** 1044 * {@inheritDoc} 1045 */ 1046 public SortedSet<Integer> getResponseResultCodeEqualTo() { 1047 return impl.getPropertyValues(INSTANCE.getResponseResultCodeEqualToPropertyDefinition()); 1048 } 1049 1050 1051 1052 /** 1053 * {@inheritDoc} 1054 */ 1055 public void setResponseResultCodeEqualTo(Collection<Integer> values) { 1056 impl.setPropertyValues(INSTANCE.getResponseResultCodeEqualToPropertyDefinition(), values); 1057 } 1058 1059 1060 1061 /** 1062 * {@inheritDoc} 1063 */ 1064 public SortedSet<Integer> getResponseResultCodeNotEqualTo() { 1065 return impl.getPropertyValues(INSTANCE.getResponseResultCodeNotEqualToPropertyDefinition()); 1066 } 1067 1068 1069 1070 /** 1071 * {@inheritDoc} 1072 */ 1073 public void setResponseResultCodeNotEqualTo(Collection<Integer> values) { 1074 impl.setPropertyValues(INSTANCE.getResponseResultCodeNotEqualToPropertyDefinition(), values); 1075 } 1076 1077 1078 1079 /** 1080 * {@inheritDoc} 1081 */ 1082 public Boolean isSearchResponseIsIndexed() { 1083 return impl.getPropertyValue(INSTANCE.getSearchResponseIsIndexedPropertyDefinition()); 1084 } 1085 1086 1087 1088 /** 1089 * {@inheritDoc} 1090 */ 1091 public void setSearchResponseIsIndexed(Boolean value) { 1092 impl.setPropertyValue(INSTANCE.getSearchResponseIsIndexedPropertyDefinition(), value); 1093 } 1094 1095 1096 1097 /** 1098 * {@inheritDoc} 1099 */ 1100 public Integer getSearchResponseNentriesGreaterThan() { 1101 return impl.getPropertyValue(INSTANCE.getSearchResponseNentriesGreaterThanPropertyDefinition()); 1102 } 1103 1104 1105 1106 /** 1107 * {@inheritDoc} 1108 */ 1109 public void setSearchResponseNentriesGreaterThan(Integer value) { 1110 impl.setPropertyValue(INSTANCE.getSearchResponseNentriesGreaterThanPropertyDefinition(), value); 1111 } 1112 1113 1114 1115 /** 1116 * {@inheritDoc} 1117 */ 1118 public Integer getSearchResponseNentriesLessThan() { 1119 return impl.getPropertyValue(INSTANCE.getSearchResponseNentriesLessThanPropertyDefinition()); 1120 } 1121 1122 1123 1124 /** 1125 * {@inheritDoc} 1126 */ 1127 public void setSearchResponseNentriesLessThan(Integer value) { 1128 impl.setPropertyValue(INSTANCE.getSearchResponseNentriesLessThanPropertyDefinition(), value); 1129 } 1130 1131 1132 1133 /** 1134 * {@inheritDoc} 1135 */ 1136 public SortedSet<String> getUserDNEqualTo() { 1137 return impl.getPropertyValues(INSTANCE.getUserDNEqualToPropertyDefinition()); 1138 } 1139 1140 1141 1142 /** 1143 * {@inheritDoc} 1144 */ 1145 public void setUserDNEqualTo(Collection<String> values) { 1146 impl.setPropertyValues(INSTANCE.getUserDNEqualToPropertyDefinition(), values); 1147 } 1148 1149 1150 1151 /** 1152 * {@inheritDoc} 1153 */ 1154 public SortedSet<String> getUserDNNotEqualTo() { 1155 return impl.getPropertyValues(INSTANCE.getUserDNNotEqualToPropertyDefinition()); 1156 } 1157 1158 1159 1160 /** 1161 * {@inheritDoc} 1162 */ 1163 public void setUserDNNotEqualTo(Collection<String> values) { 1164 impl.setPropertyValues(INSTANCE.getUserDNNotEqualToPropertyDefinition(), values); 1165 } 1166 1167 1168 1169 /** 1170 * {@inheritDoc} 1171 */ 1172 public SortedSet<DN> getUserIsMemberOf() { 1173 return impl.getPropertyValues(INSTANCE.getUserIsMemberOfPropertyDefinition()); 1174 } 1175 1176 1177 1178 /** 1179 * {@inheritDoc} 1180 */ 1181 public void setUserIsMemberOf(Collection<DN> values) { 1182 impl.setPropertyValues(INSTANCE.getUserIsMemberOfPropertyDefinition(), values); 1183 } 1184 1185 1186 1187 /** 1188 * {@inheritDoc} 1189 */ 1190 public SortedSet<DN> getUserIsNotMemberOf() { 1191 return impl.getPropertyValues(INSTANCE.getUserIsNotMemberOfPropertyDefinition()); 1192 } 1193 1194 1195 1196 /** 1197 * {@inheritDoc} 1198 */ 1199 public void setUserIsNotMemberOf(Collection<DN> values) { 1200 impl.setPropertyValues(INSTANCE.getUserIsNotMemberOfPropertyDefinition(), values); 1201 } 1202 1203 1204 1205 /** 1206 * {@inheritDoc} 1207 */ 1208 public ManagedObjectDefinition<? extends AccessLogFilteringCriteriaCfgClient, ? extends AccessLogFilteringCriteriaCfg> definition() { 1209 return INSTANCE; 1210 } 1211 1212 1213 1214 /** 1215 * {@inheritDoc} 1216 */ 1217 public PropertyProvider properties() { 1218 return impl; 1219 } 1220 1221 1222 1223 /** 1224 * {@inheritDoc} 1225 */ 1226 public void commit() throws ManagedObjectAlreadyExistsException, 1227 MissingMandatoryPropertiesException, ConcurrentModificationException, 1228 OperationRejectedException, LdapException { 1229 impl.commit(); 1230 } 1231 1232 } 1233 1234 1235 1236 /** 1237 * Managed object server implementation. 1238 */ 1239 private static class AccessLogFilteringCriteriaCfgServerImpl implements 1240 AccessLogFilteringCriteriaCfg { 1241 1242 // Private implementation. 1243 private ServerManagedObject<? extends AccessLogFilteringCriteriaCfg> impl; 1244 1245 // The value of the "connection-client-address-equal-to" property. 1246 private final SortedSet<AddressMask> pConnectionClientAddressEqualTo; 1247 1248 // The value of the "connection-client-address-not-equal-to" property. 1249 private final SortedSet<AddressMask> pConnectionClientAddressNotEqualTo; 1250 1251 // The value of the "connection-port-equal-to" property. 1252 private final SortedSet<Integer> pConnectionPortEqualTo; 1253 1254 // The value of the "connection-protocol-equal-to" property. 1255 private final SortedSet<String> pConnectionProtocolEqualTo; 1256 1257 // The value of the "log-record-type" property. 1258 private final SortedSet<LogRecordType> pLogRecordType; 1259 1260 // The value of the "request-target-dn-equal-to" property. 1261 private final SortedSet<String> pRequestTargetDNEqualTo; 1262 1263 // The value of the "request-target-dn-not-equal-to" property. 1264 private final SortedSet<String> pRequestTargetDNNotEqualTo; 1265 1266 // The value of the "response-etime-greater-than" property. 1267 private final Integer pResponseEtimeGreaterThan; 1268 1269 // The value of the "response-etime-less-than" property. 1270 private final Integer pResponseEtimeLessThan; 1271 1272 // The value of the "response-result-code-equal-to" property. 1273 private final SortedSet<Integer> pResponseResultCodeEqualTo; 1274 1275 // The value of the "response-result-code-not-equal-to" property. 1276 private final SortedSet<Integer> pResponseResultCodeNotEqualTo; 1277 1278 // The value of the "search-response-is-indexed" property. 1279 private final Boolean pSearchResponseIsIndexed; 1280 1281 // The value of the "search-response-nentries-greater-than" property. 1282 private final Integer pSearchResponseNentriesGreaterThan; 1283 1284 // The value of the "search-response-nentries-less-than" property. 1285 private final Integer pSearchResponseNentriesLessThan; 1286 1287 // The value of the "user-dn-equal-to" property. 1288 private final SortedSet<String> pUserDNEqualTo; 1289 1290 // The value of the "user-dn-not-equal-to" property. 1291 private final SortedSet<String> pUserDNNotEqualTo; 1292 1293 // The value of the "user-is-member-of" property. 1294 private final SortedSet<DN> pUserIsMemberOf; 1295 1296 // The value of the "user-is-not-member-of" property. 1297 private final SortedSet<DN> pUserIsNotMemberOf; 1298 1299 1300 1301 // Private constructor. 1302 private AccessLogFilteringCriteriaCfgServerImpl(ServerManagedObject<? extends AccessLogFilteringCriteriaCfg> impl) { 1303 this.impl = impl; 1304 this.pConnectionClientAddressEqualTo = impl.getPropertyValues(INSTANCE.getConnectionClientAddressEqualToPropertyDefinition()); 1305 this.pConnectionClientAddressNotEqualTo = impl.getPropertyValues(INSTANCE.getConnectionClientAddressNotEqualToPropertyDefinition()); 1306 this.pConnectionPortEqualTo = impl.getPropertyValues(INSTANCE.getConnectionPortEqualToPropertyDefinition()); 1307 this.pConnectionProtocolEqualTo = impl.getPropertyValues(INSTANCE.getConnectionProtocolEqualToPropertyDefinition()); 1308 this.pLogRecordType = impl.getPropertyValues(INSTANCE.getLogRecordTypePropertyDefinition()); 1309 this.pRequestTargetDNEqualTo = impl.getPropertyValues(INSTANCE.getRequestTargetDNEqualToPropertyDefinition()); 1310 this.pRequestTargetDNNotEqualTo = impl.getPropertyValues(INSTANCE.getRequestTargetDNNotEqualToPropertyDefinition()); 1311 this.pResponseEtimeGreaterThan = impl.getPropertyValue(INSTANCE.getResponseEtimeGreaterThanPropertyDefinition()); 1312 this.pResponseEtimeLessThan = impl.getPropertyValue(INSTANCE.getResponseEtimeLessThanPropertyDefinition()); 1313 this.pResponseResultCodeEqualTo = impl.getPropertyValues(INSTANCE.getResponseResultCodeEqualToPropertyDefinition()); 1314 this.pResponseResultCodeNotEqualTo = impl.getPropertyValues(INSTANCE.getResponseResultCodeNotEqualToPropertyDefinition()); 1315 this.pSearchResponseIsIndexed = impl.getPropertyValue(INSTANCE.getSearchResponseIsIndexedPropertyDefinition()); 1316 this.pSearchResponseNentriesGreaterThan = impl.getPropertyValue(INSTANCE.getSearchResponseNentriesGreaterThanPropertyDefinition()); 1317 this.pSearchResponseNentriesLessThan = impl.getPropertyValue(INSTANCE.getSearchResponseNentriesLessThanPropertyDefinition()); 1318 this.pUserDNEqualTo = impl.getPropertyValues(INSTANCE.getUserDNEqualToPropertyDefinition()); 1319 this.pUserDNNotEqualTo = impl.getPropertyValues(INSTANCE.getUserDNNotEqualToPropertyDefinition()); 1320 this.pUserIsMemberOf = impl.getPropertyValues(INSTANCE.getUserIsMemberOfPropertyDefinition()); 1321 this.pUserIsNotMemberOf = impl.getPropertyValues(INSTANCE.getUserIsNotMemberOfPropertyDefinition()); 1322 } 1323 1324 1325 1326 /** 1327 * {@inheritDoc} 1328 */ 1329 public void addChangeListener( 1330 ConfigurationChangeListener<AccessLogFilteringCriteriaCfg> listener) { 1331 impl.registerChangeListener(listener); 1332 } 1333 1334 1335 1336 /** 1337 * {@inheritDoc} 1338 */ 1339 public void removeChangeListener( 1340 ConfigurationChangeListener<AccessLogFilteringCriteriaCfg> listener) { 1341 impl.deregisterChangeListener(listener); 1342 } 1343 1344 1345 1346 /** 1347 * {@inheritDoc} 1348 */ 1349 public SortedSet<AddressMask> getConnectionClientAddressEqualTo() { 1350 return pConnectionClientAddressEqualTo; 1351 } 1352 1353 1354 1355 /** 1356 * {@inheritDoc} 1357 */ 1358 public SortedSet<AddressMask> getConnectionClientAddressNotEqualTo() { 1359 return pConnectionClientAddressNotEqualTo; 1360 } 1361 1362 1363 1364 /** 1365 * {@inheritDoc} 1366 */ 1367 public SortedSet<Integer> getConnectionPortEqualTo() { 1368 return pConnectionPortEqualTo; 1369 } 1370 1371 1372 1373 /** 1374 * {@inheritDoc} 1375 */ 1376 public SortedSet<String> getConnectionProtocolEqualTo() { 1377 return pConnectionProtocolEqualTo; 1378 } 1379 1380 1381 1382 /** 1383 * {@inheritDoc} 1384 */ 1385 public SortedSet<LogRecordType> getLogRecordType() { 1386 return pLogRecordType; 1387 } 1388 1389 1390 1391 /** 1392 * {@inheritDoc} 1393 */ 1394 public SortedSet<String> getRequestTargetDNEqualTo() { 1395 return pRequestTargetDNEqualTo; 1396 } 1397 1398 1399 1400 /** 1401 * {@inheritDoc} 1402 */ 1403 public SortedSet<String> getRequestTargetDNNotEqualTo() { 1404 return pRequestTargetDNNotEqualTo; 1405 } 1406 1407 1408 1409 /** 1410 * {@inheritDoc} 1411 */ 1412 public Integer getResponseEtimeGreaterThan() { 1413 return pResponseEtimeGreaterThan; 1414 } 1415 1416 1417 1418 /** 1419 * {@inheritDoc} 1420 */ 1421 public Integer getResponseEtimeLessThan() { 1422 return pResponseEtimeLessThan; 1423 } 1424 1425 1426 1427 /** 1428 * {@inheritDoc} 1429 */ 1430 public SortedSet<Integer> getResponseResultCodeEqualTo() { 1431 return pResponseResultCodeEqualTo; 1432 } 1433 1434 1435 1436 /** 1437 * {@inheritDoc} 1438 */ 1439 public SortedSet<Integer> getResponseResultCodeNotEqualTo() { 1440 return pResponseResultCodeNotEqualTo; 1441 } 1442 1443 1444 1445 /** 1446 * {@inheritDoc} 1447 */ 1448 public Boolean isSearchResponseIsIndexed() { 1449 return pSearchResponseIsIndexed; 1450 } 1451 1452 1453 1454 /** 1455 * {@inheritDoc} 1456 */ 1457 public Integer getSearchResponseNentriesGreaterThan() { 1458 return pSearchResponseNentriesGreaterThan; 1459 } 1460 1461 1462 1463 /** 1464 * {@inheritDoc} 1465 */ 1466 public Integer getSearchResponseNentriesLessThan() { 1467 return pSearchResponseNentriesLessThan; 1468 } 1469 1470 1471 1472 /** 1473 * {@inheritDoc} 1474 */ 1475 public SortedSet<String> getUserDNEqualTo() { 1476 return pUserDNEqualTo; 1477 } 1478 1479 1480 1481 /** 1482 * {@inheritDoc} 1483 */ 1484 public SortedSet<String> getUserDNNotEqualTo() { 1485 return pUserDNNotEqualTo; 1486 } 1487 1488 1489 1490 /** 1491 * {@inheritDoc} 1492 */ 1493 public SortedSet<DN> getUserIsMemberOf() { 1494 return pUserIsMemberOf; 1495 } 1496 1497 1498 1499 /** 1500 * {@inheritDoc} 1501 */ 1502 public SortedSet<DN> getUserIsNotMemberOf() { 1503 return pUserIsNotMemberOf; 1504 } 1505 1506 1507 1508 /** 1509 * {@inheritDoc} 1510 */ 1511 public Class<? extends AccessLogFilteringCriteriaCfg> configurationClass() { 1512 return AccessLogFilteringCriteriaCfg.class; 1513 } 1514 1515 1516 1517 /** 1518 * {@inheritDoc} 1519 */ 1520 public DN dn() { 1521 return impl.getDN(); 1522 } 1523 1524 } 1525}