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