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