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