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