001/*
002 * Copyright 2009-2018 Ping Identity Corporation
003 * All Rights Reserved.
004 */
005/*
006 * Copyright (C) 2015-2018 Ping Identity Corporation
007 *
008 * This program is free software; you can redistribute it and/or modify
009 * it under the terms of the GNU General Public License (GPLv2 only)
010 * or the terms of the GNU Lesser General Public License (LGPLv2.1 only)
011 * as published by the Free Software Foundation.
012 *
013 * This program is distributed in the hope that it will be useful,
014 * but WITHOUT ANY WARRANTY; without even the implied warranty of
015 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
016 * GNU General Public License for more details.
017 *
018 * You should have received a copy of the GNU General Public License
019 * along with this program; if not, see <http://www.gnu.org/licenses>.
020 */
021package com.unboundid.ldap.sdk.unboundidds.monitors;
022
023
024
025import java.util.Collections;
026import java.util.Date;
027import java.util.LinkedHashMap;
028import java.util.List;
029import java.util.Map;
030
031import com.unboundid.ldap.sdk.Entry;
032import com.unboundid.util.NotMutable;
033import com.unboundid.util.ThreadSafety;
034import com.unboundid.util.ThreadSafetyLevel;
035
036import static com.unboundid.ldap.sdk.unboundidds.monitors.MonitorMessages.*;
037
038
039
040/**
041 * This class defines a monitor entry that provides general information about
042 * an LDAP external server used by the Directory Proxy Server.
043 * <BR>
044 * <BLOCKQUOTE>
045 *   <B>NOTE:</B>  This class, and other classes within the
046 *   {@code com.unboundid.ldap.sdk.unboundidds} package structure, are only
047 *   supported for use against Ping Identity, UnboundID, and Alcatel-Lucent 8661
048 *   server products.  These classes provide support for proprietary
049 *   functionality or for external specifications that are not considered stable
050 *   or mature enough to be guaranteed to work in an interoperable way with
051 *   other types of LDAP servers.
052 * </BLOCKQUOTE>
053 * <BR>
054 * Information that it may make available includes:
055 * <UL>
056 *   <LI>The address, port, and security mechanism used to communicate with the
057 *       server.</LI>
058 *   <LI>The DN of the configuration entry for the load-balancing algorithm that
059 *       is using the LDAP external server object.</LI>
060 *   <LI>Information about the health of the LDAP external server.</LI>
061 *   <LI>The number of attempted, successful, and failed operations processed
062 *       using the LDAP external server.</LI>
063 * </UL>
064 * The server should present an LDAP external server monitor entry for each
065 * server used by each load-balancing algorithm.  These entries can be retrieved
066 * using the {@link MonitorManager#getLDAPExternalServerMonitorEntries} method.
067 * These entries provide specific methods for accessing this information.
068 * Alternately, the information may be accessed using the generic API.  See the
069 * {@link MonitorManager} class documentation for an example that demonstrates
070 * the use of the generic API for accessing monitor data.
071 */
072@NotMutable()
073@ThreadSafety(level=ThreadSafetyLevel.COMPLETELY_THREADSAFE)
074public final class LDAPExternalServerMonitorEntry
075       extends MonitorEntry
076{
077  /**
078   * The structural object class used in LDAP external server monitor entries.
079   */
080  protected static final String LDAP_EXTERNAL_SERVER_MONITOR_OC =
081       "ds-ldap-external-server-monitor-entry";
082
083
084
085  /**
086   * The name of the attribute used to provide the number of add operations
087   * attempted in the backend server.
088   */
089  private static final String ATTR_ADD_ATTEMPTS = "add-attempts";
090
091
092
093  /**
094   * The name of the attribute used to provide the number of add operations
095   * that failed.
096   */
097  private static final String ATTR_ADD_FAILURES = "add-failures";
098
099
100
101  /**
102   * The name of the attribute used to provide the number of add operations
103   * completed successfully.
104   */
105  private static final String ATTR_ADD_SUCCESSES = "add-successes";
106
107
108
109  /**
110   * The name of the attribute used to provide the number of bind operations
111   * attempted in the backend server.
112   */
113  private static final String ATTR_BIND_ATTEMPTS = "bind-attempts";
114
115
116
117  /**
118   * The name of the attribute used to provide the number of bind operations
119   * that failed.
120   */
121  private static final String ATTR_BIND_FAILURES = "bind-failures";
122
123
124
125  /**
126   * The name of the attribute used to provide the number of bind operations
127   * completed successfully.
128   */
129  private static final String ATTR_BIND_SUCCESSES = "bind-successes";
130
131
132
133  /**
134   * The name of the attribute used to provide the communication security
135   * mechanism.
136   */
137  private static final String ATTR_COMMUNICATION_SECURITY =
138       "communication-security";
139
140
141
142  /**
143   * The name of the attribute used to provide the number of compare operations
144   * attempted in the backend server.
145   */
146  private static final String ATTR_COMPARE_ATTEMPTS = "compare-attempts";
147
148
149
150  /**
151   * The name of the attribute used to provide the number of compare operations
152   * that failed.
153   */
154  private static final String ATTR_COMPARE_FAILURES = "compare-failures";
155
156
157
158  /**
159   * The name of the attribute used to provide the number of compare operations
160   * completed successfully.
161   */
162  private static final String ATTR_COMPARE_SUCCESSES = "compare-successes";
163
164
165
166  /**
167   * The name of the attribute used to provide the number of delete operations
168   * attempted in the backend server.
169   */
170  private static final String ATTR_DELETE_ATTEMPTS = "delete-attempts";
171
172
173
174  /**
175   * The name of the attribute used to provide the number of delete operations
176   * that failed.
177   */
178  private static final String ATTR_DELETE_FAILURES = "delete-failures";
179
180
181
182  /**
183   * The name of the attribute used to provide the number of delete operations
184   * completed successfully.
185   */
186  private static final String ATTR_DELETE_SUCCESSES = "delete-successes";
187
188
189
190  /**
191   * The name of the attribute used to provide health check messages.
192   */
193  private static final String ATTR_HEALTH_CHECK_MESSAGE =
194       "health-check-message";
195
196
197
198  /**
199   * The name of the attribute used to provide the health check state.
200   */
201  private static final String ATTR_HEALTH_CHECK_STATE = "health-check-state";
202
203
204
205  /**
206   * The name of the attribute used to provide the health check score.
207   */
208  private static final String ATTR_HEALTH_CHECK_SCORE = "health-check-score";
209
210
211
212  /**
213   * The name of the attribute used to provide the time the health check
214   * information was last updated.
215   */
216  private static final String ATTR_HEALTH_CHECK_UPDATE_TIME =
217       "health-check-update-time";
218
219
220
221  /**
222   * The name of the attribute used to provide the DN of the load-balancing
223   * algorithm configuration entry.
224   */
225  private static final String ATTR_LOAD_BALANCING_ALGORITHM_DN =
226       "load-balancing-algorithm";
227
228
229
230  /**
231   * The name of the attribute used to provide the number of modify operations
232   * attempted in the backend server.
233   */
234  private static final String ATTR_MODIFY_ATTEMPTS = "modify-attempts";
235
236
237
238  /**
239   * The name of the attribute used to provide the number of modify operations
240   * that failed.
241   */
242  private static final String ATTR_MODIFY_FAILURES = "modify-failures";
243
244
245
246  /**
247   * The name of the attribute used to provide the number of modify operations
248   * completed successfully.
249   */
250  private static final String ATTR_MODIFY_SUCCESSES = "modify-successes";
251
252
253
254  /**
255   * The name of the attribute used to provide the number of modify DN
256   * operations attempted in the backend server.
257   */
258  private static final String ATTR_MODIFY_DN_ATTEMPTS = "modify-dn-attempts";
259
260
261
262  /**
263   * The name of the attribute used to provide the number of modify DN
264   * operations that failed.
265   */
266  private static final String ATTR_MODIFY_DN_FAILURES = "modify-dn-failures";
267
268
269
270  /**
271   * The name of the attribute used to provide the number of modify DN
272   * operations completed successfully.
273   */
274  private static final String ATTR_MODIFY_DN_SUCCESSES = "modify-dn-successes";
275
276
277
278  /**
279   * The name of the attribute used to provide the number of search operations
280   * attempted in the backend server.
281   */
282  private static final String ATTR_SEARCH_ATTEMPTS = "search-attempts";
283
284
285
286  /**
287   * The name of the attribute used to provide the number of search operations
288   * that failed.
289   */
290  private static final String ATTR_SEARCH_FAILURES = "search-failures";
291
292
293
294  /**
295   * The name of the attribute used to provide the number of search operations
296   * completed successfully.
297   */
298  private static final String ATTR_SEARCH_SUCCESSES = "search-successes";
299
300
301
302  /**
303   * The name of the attribute used to provide the server address.
304   */
305  private static final String ATTR_SERVER_ADDRESS = "server-address";
306
307
308
309  /**
310   * The name of the attribute used to provide the server port.
311   */
312  private static final String ATTR_SERVER_PORT = "server-port";
313
314
315
316  /**
317   * The prefix for attributes providing information from a connection pool used
318   * only for bind operations.
319   */
320  private static final String ATTR_PREFIX_BIND_POOL = "bind-";
321
322
323
324  /**
325   * The prefix for attributes providing information from a connection pool used
326   * for all types of operations.
327   */
328  private static final String ATTR_PREFIX_COMMON_POOL = "common-";
329
330
331
332  /**
333   * The prefix for attributes providing information from a connection pool used
334   * only for non-bind operations.
335   */
336  private static final String ATTR_PREFIX_NONBIND_POOL = "non-bind-";
337
338
339
340  /**
341   * The suffix for the attribute used to provide the number of available
342   * connections from a pool.
343   */
344  private static final String ATTR_SUFFIX_AVAILABLE_CONNS =
345       "pool-available-connections";
346
347
348
349  /**
350   * The suffix for the attribute used to provide the number of connections
351   * closed as defunct.
352   */
353  private static final String ATTR_SUFFIX_CLOSED_DEFUNCT =
354       "pool-num-closed-defunct";
355
356
357
358  /**
359   * The suffix for the attribute used to provide the number of connections
360   * closed as expired.
361   */
362  private static final String ATTR_SUFFIX_CLOSED_EXPIRED =
363       "pool-num-closed-expired";
364
365
366
367  /**
368   * The suffix for the attribute used to provide the number of connections
369   * closed as unneeded.
370   */
371  private static final String ATTR_SUFFIX_CLOSED_UNNEEDED =
372       "pool-num-closed-unneeded";
373
374
375
376  /**
377   * The suffix for the attribute used to provide the number of failed
378   * checkouts.
379   */
380  private static final String ATTR_SUFFIX_FAILED_CHECKOUTS =
381       "pool-num-failed-checkouts";
382
383
384
385  /**
386   * The suffix for the attribute used to provide the number of failed
387   * connection attempts.
388   */
389  private static final String ATTR_SUFFIX_FAILED_CONNECTS =
390       "pool-num-failed-connection-attempts";
391
392
393
394  /**
395   * The suffix for the attribute used to provide the maximum number of
396   * available connections from a pool.
397   */
398  private static final String ATTR_SUFFIX_MAX_AVAILABLE_CONNS =
399       "pool-max-available-connections";
400
401
402
403  /**
404   * The suffix for the attribute used to provide the number of connections
405   * released as valid back to the pool.
406   */
407  private static final String ATTR_SUFFIX_RELEASED_VALID =
408       "pool-num-released-valid";
409
410
411
412  /**
413   * The suffix for the attribute used to provide the number of successful
414   * checkouts.
415   */
416  private static final String ATTR_SUFFIX_SUCCESSFUL_CHECKOUTS =
417       "pool-num-successful-checkouts";
418
419
420
421  /**
422   * The suffix for the attribute used to provide the number of successful
423   * checkouts after waiting for a connection to become available.
424   */
425  private static final String ATTR_SUFFIX_SUCCESSFUL_CHECKOUTS_AFTER_WAITING =
426       "pool-num-successful-checkouts-after-waiting";
427
428
429
430  /**
431   * The suffix for the attribute used to provide the number of successful
432   * checkouts after creating a new connection.
433   */
434  private static final String ATTR_SUFFIX_SUCCESSFUL_CHECKOUTS_NEW_CONN =
435       "pool-num-successful-checkouts-new-connection";
436
437
438
439  /**
440   * The suffix for the attribute used to provide the number of successful
441   * checkouts without waiting.
442   */
443  private static final String ATTR_SUFFIX_SUCCESSFUL_CHECKOUTS_WITHOUT_WAITING =
444       "pool-num-successful-checkouts-without-waiting";
445
446
447
448  /**
449   * The suffix for the attribute used to provide the number of successful
450   * connection attempts.
451   */
452  private static final String ATTR_SUFFIX_SUCCESSFUL_CONNECTS =
453       "pool-num-successful-connection-attempts";
454
455
456
457  /**
458   * The serial version UID for this serializable class.
459   */
460  private static final long serialVersionUID = 6054649631882735072L;
461
462
463
464  // The time the health check information was last updated.
465  private final Date healthCheckUpdateTime;
466
467  // The health check state for the server.
468  private final HealthCheckState healthCheckState;
469
470  // The list of health check messages.
471  private final List<String> healthCheckMessages;
472
473  // The number of add operations attempted.
474  private final Long addAttempts;
475
476  // The number of failed add operations.
477  private final Long addFailures;
478
479  // The number of successful add operations.
480  private final Long addSuccesses;
481
482  // The number of bind operations attempted.
483  private final Long bindAttempts;
484
485  // The number of failed bind operations.
486  private final Long bindFailures;
487
488  // The number of available connections in the bind pool.
489  private final Long bindPoolAvailableConnections;
490
491  // The maximum number of available connections in the bind pool.
492  private final Long bindPoolMaxAvailableConnections;
493
494  // The number of connections in the bind pool that have been closed as
495  // defunct.
496  private final Long bindPoolNumClosedDefunct;
497
498  // The number of connections in the bind pool that have been closed as
499  // expired.
500  private final Long bindPoolNumClosedExpired;
501
502  // The number of connections in the bind pool that have been closed as
503  // unneeded.
504  private final Long bindPoolNumClosedUnneeded;
505
506  // The number of available failed checkouts in the bind pool.
507  private final Long bindPoolNumFailedCheckouts;
508
509  // The number of available failed connection attempts in the bind pool.
510  private final Long bindPoolNumFailedConnectionAttempts;
511
512  // The total number of connections released as valid back to the bind pool.
513  private final Long bindPoolNumReleasedValid;
514
515  // The total number of successful checkouts from the bind pool.
516  private final Long bindPoolNumSuccessfulCheckouts;
517
518  // The total number of successful checkouts from the bind pool after waiting
519  // for a connection to become available.
520  private final Long bindPoolNumSuccessfulCheckoutsAfterWaiting;
521
522  // The total number of successful checkouts from the bind pool after creating
523  // a new connection.
524  private final Long bindPoolNumSuccessfulCheckoutsNewConnection;
525
526  // The total number of successful checkouts from the bind pool without waiting
527  // for a connection to become available.
528  private final Long bindPoolNumSuccessfulCheckoutsWithoutWaiting;
529
530  // The number of successful connection attempts in the bind pool.
531  private final Long bindPoolNumSuccessfulConnectionAttempts;
532
533  // The number of successful bind operations.
534  private final Long bindSuccesses;
535
536  // The number of available connections in the common pool.
537  private final Long commonPoolAvailableConnections;
538
539  // The maximum number of available connections in the common pool.
540  private final Long commonPoolMaxAvailableConnections;
541
542  // The number of connections in the common pool that have been closed as
543  // defunct.
544  private final Long commonPoolNumClosedDefunct;
545
546  // The number of connections in the common pool that have been closed as
547  // expired.
548  private final Long commonPoolNumClosedExpired;
549
550  // The number of connections in the common pool that have been closed as
551  // unneeded.
552  private final Long commonPoolNumClosedUnneeded;
553
554  // The number of available failed checkouts in the common pool.
555  private final Long commonPoolNumFailedCheckouts;
556
557  // The number of available failed connection attempts in the common pool.
558  private final Long commonPoolNumFailedConnectionAttempts;
559
560  // The total number of connections released as valid back to the common pool.
561  private final Long commonPoolNumReleasedValid;
562
563  // The total number of successful checkouts from the common pool.
564  private final Long commonPoolNumSuccessfulCheckouts;
565
566  // The total number of successful checkouts from the common pool after waiting
567  // for a connection to become available.
568  private final Long commonPoolNumSuccessfulCheckoutsAfterWaiting;
569
570  // The total number of successful checkouts from the common pool after
571  // creating a new connection.
572  private final Long commonPoolNumSuccessfulCheckoutsNewConnection;
573
574  // The total number of successful checkouts from the common pool without
575  // waiting for a connection to become available.
576  private final Long commonPoolNumSuccessfulCheckoutsWithoutWaiting;
577
578  // The number of successful connection attempts in the common pool.
579  private final Long commonPoolNumSuccessfulConnectionAttempts;
580
581  // The number of compare operations attempted.
582  private final Long compareAttempts;
583
584  // The number of failed compare operations.
585  private final Long compareFailures;
586
587  // The number of successful compare operations.
588  private final Long compareSuccesses;
589
590  // The number of delete operations attempted.
591  private final Long deleteAttempts;
592
593  // The number of failed delete operations.
594  private final Long deleteFailures;
595
596  // The number of successful delete operations.
597  private final Long deleteSuccesses;
598
599  // The health check score for the server.
600  private final Long healthCheckScore;
601
602  // The number of modify operations attempted.
603  private final Long modifyAttempts;
604
605  // The number of failed modify operations.
606  private final Long modifyFailures;
607
608  // The number of successful modify operations.
609  private final Long modifySuccesses;
610
611  // The number of modify DN operations attempted.
612  private final Long modifyDNAttempts;
613
614  // The number of failed modify DN operations.
615  private final Long modifyDNFailures;
616
617  // The number of successful modify DN operations.
618  private final Long modifyDNSuccesses;
619
620  // The number of available connections in the non-bind pool.
621  private final Long nonBindPoolAvailableConnections;
622
623  // The maximum number of available connections in the non-bind pool.
624  private final Long nonBindPoolMaxAvailableConnections;
625
626  // The number of connections in the non-bind pool that have been closed as
627  // defunct.
628  private final Long nonBindPoolNumClosedDefunct;
629
630  // The number of connections in the non-bind pool that have been closed as
631  // expired.
632  private final Long nonBindPoolNumClosedExpired;
633
634  // The number of connections in the non-bind pool that have been closed as
635  // unneeded.
636  private final Long nonBindPoolNumClosedUnneeded;
637
638  // The number of available failed checkouts in the non-bind pool.
639  private final Long nonBindPoolNumFailedCheckouts;
640
641  // The number of available failed connection attempts in the non-bind pool.
642  private final Long nonBindPoolNumFailedConnectionAttempts;
643
644  // The total number of connections released as valid back to the non-bind
645  // pool.
646  private final Long nonBindPoolNumReleasedValid;
647
648  // The total number of successful checkouts from the non-bind pool.
649  private final Long nonBindPoolNumSuccessfulCheckouts;
650
651  // The total number of successful checkouts from the non-bind pool after
652  // waiting for a connection to become available.
653  private final Long nonBindPoolNumSuccessfulCheckoutsAfterWaiting;
654
655  // The total number of successful checkouts from the non-bind pool after
656  // creating a new connection.
657  private final Long nonBindPoolNumSuccessfulCheckoutsNewConnection;
658
659  // The total number of successful checkouts from the non-bind pool without
660  // waiting for a connection to become available.
661  private final Long nonBindPoolNumSuccessfulCheckoutsWithoutWaiting;
662
663  // The number of successful connection attempts in the non-bind pool.
664  private final Long nonBindPoolNumSuccessfulConnectionAttempts;
665
666  // The number of search operations attempted.
667  private final Long searchAttempts;
668
669  // The number of failed search operations.
670  private final Long searchFailures;
671
672  // The number of successful search operations.
673  private final Long searchSuccesses;
674
675  // The port of the server.
676  private final Long serverPort;
677
678  // The communication security mechanism used by the server.
679  private final String communicationSecurity;
680
681  // The DN of the load-balancing algorithm.
682  private final String loadBalancingAlgorithmDN;
683
684  // The address of the server.
685  private final String serverAddress;
686
687
688
689  /**
690   * Creates a new LDAP external server monitor entry from the provided entry.
691   *
692   * @param  entry  The entry to be parsed as an LDAP external server monitor
693   *                entry.  It must not be {@code null}.
694   */
695  public LDAPExternalServerMonitorEntry(final Entry entry)
696  {
697    super(entry);
698
699    serverAddress            = getString(ATTR_SERVER_ADDRESS);
700    serverPort               = getLong(ATTR_SERVER_PORT);
701    communicationSecurity    = getString(ATTR_COMMUNICATION_SECURITY);
702    loadBalancingAlgorithmDN = getString(ATTR_LOAD_BALANCING_ALGORITHM_DN);
703    healthCheckScore         = getLong(ATTR_HEALTH_CHECK_SCORE);
704    healthCheckMessages      = getStrings(ATTR_HEALTH_CHECK_MESSAGE);
705    healthCheckUpdateTime    = getDate(ATTR_HEALTH_CHECK_UPDATE_TIME);
706    addAttempts              = getLong(ATTR_ADD_ATTEMPTS);
707    addFailures              = getLong(ATTR_ADD_FAILURES);
708    addSuccesses             = getLong(ATTR_ADD_SUCCESSES);
709    bindAttempts             = getLong(ATTR_BIND_ATTEMPTS);
710    bindFailures             = getLong(ATTR_BIND_FAILURES);
711    bindSuccesses            = getLong(ATTR_BIND_SUCCESSES);
712    compareAttempts          = getLong(ATTR_COMPARE_ATTEMPTS);
713    compareFailures          = getLong(ATTR_COMPARE_FAILURES);
714    compareSuccesses         = getLong(ATTR_COMPARE_SUCCESSES);
715    deleteAttempts           = getLong(ATTR_DELETE_ATTEMPTS);
716    deleteFailures           = getLong(ATTR_DELETE_FAILURES);
717    deleteSuccesses          = getLong(ATTR_DELETE_SUCCESSES);
718    modifyAttempts           = getLong(ATTR_MODIFY_ATTEMPTS);
719    modifyFailures           = getLong(ATTR_MODIFY_FAILURES);
720    modifySuccesses          = getLong(ATTR_MODIFY_SUCCESSES);
721    modifyDNAttempts         = getLong(ATTR_MODIFY_DN_ATTEMPTS);
722    modifyDNFailures         = getLong(ATTR_MODIFY_DN_FAILURES);
723    modifyDNSuccesses        = getLong(ATTR_MODIFY_DN_SUCCESSES);
724    searchAttempts           = getLong(ATTR_SEARCH_ATTEMPTS);
725    searchFailures           = getLong(ATTR_SEARCH_FAILURES);
726    searchSuccesses          = getLong(ATTR_SEARCH_SUCCESSES);
727
728    bindPoolAvailableConnections = getLong(ATTR_PREFIX_BIND_POOL +
729         ATTR_SUFFIX_AVAILABLE_CONNS);
730    bindPoolMaxAvailableConnections = getLong(ATTR_PREFIX_BIND_POOL +
731         ATTR_SUFFIX_MAX_AVAILABLE_CONNS);
732    bindPoolNumSuccessfulConnectionAttempts = getLong(ATTR_PREFIX_BIND_POOL +
733         ATTR_SUFFIX_SUCCESSFUL_CONNECTS);
734    bindPoolNumFailedConnectionAttempts = getLong(ATTR_PREFIX_BIND_POOL +
735         ATTR_SUFFIX_FAILED_CONNECTS);
736    bindPoolNumClosedDefunct = getLong(ATTR_PREFIX_BIND_POOL +
737         ATTR_SUFFIX_CLOSED_DEFUNCT);
738    bindPoolNumClosedExpired = getLong(ATTR_PREFIX_BIND_POOL +
739         ATTR_SUFFIX_CLOSED_EXPIRED);
740    bindPoolNumClosedUnneeded = getLong(ATTR_PREFIX_BIND_POOL +
741         ATTR_SUFFIX_CLOSED_UNNEEDED);
742    bindPoolNumSuccessfulCheckouts = getLong(ATTR_PREFIX_BIND_POOL +
743         ATTR_SUFFIX_SUCCESSFUL_CHECKOUTS);
744    bindPoolNumSuccessfulCheckoutsWithoutWaiting = getLong(
745         ATTR_PREFIX_BIND_POOL +
746         ATTR_SUFFIX_SUCCESSFUL_CHECKOUTS_WITHOUT_WAITING);
747    bindPoolNumSuccessfulCheckoutsAfterWaiting = getLong(ATTR_PREFIX_BIND_POOL +
748         ATTR_SUFFIX_SUCCESSFUL_CHECKOUTS_AFTER_WAITING);
749    bindPoolNumSuccessfulCheckoutsNewConnection = getLong(
750         ATTR_PREFIX_BIND_POOL + ATTR_SUFFIX_SUCCESSFUL_CHECKOUTS_NEW_CONN);
751    bindPoolNumFailedCheckouts = getLong(ATTR_PREFIX_BIND_POOL +
752         ATTR_SUFFIX_FAILED_CHECKOUTS);
753    bindPoolNumReleasedValid = getLong(ATTR_PREFIX_BIND_POOL +
754         ATTR_SUFFIX_RELEASED_VALID);
755
756    commonPoolAvailableConnections = getLong(ATTR_PREFIX_COMMON_POOL +
757         ATTR_SUFFIX_AVAILABLE_CONNS);
758    commonPoolMaxAvailableConnections = getLong(ATTR_PREFIX_COMMON_POOL +
759         ATTR_SUFFIX_MAX_AVAILABLE_CONNS);
760    commonPoolNumSuccessfulConnectionAttempts = getLong(
761         ATTR_PREFIX_COMMON_POOL + ATTR_SUFFIX_SUCCESSFUL_CONNECTS);
762    commonPoolNumFailedConnectionAttempts = getLong(ATTR_PREFIX_COMMON_POOL +
763         ATTR_SUFFIX_FAILED_CONNECTS);
764    commonPoolNumClosedDefunct = getLong(ATTR_PREFIX_COMMON_POOL +
765         ATTR_SUFFIX_CLOSED_DEFUNCT);
766    commonPoolNumClosedExpired = getLong(ATTR_PREFIX_COMMON_POOL +
767         ATTR_SUFFIX_CLOSED_EXPIRED);
768    commonPoolNumClosedUnneeded = getLong(ATTR_PREFIX_COMMON_POOL +
769         ATTR_SUFFIX_CLOSED_UNNEEDED);
770    commonPoolNumSuccessfulCheckouts = getLong(ATTR_PREFIX_COMMON_POOL +
771         ATTR_SUFFIX_SUCCESSFUL_CHECKOUTS);
772    commonPoolNumSuccessfulCheckoutsWithoutWaiting = getLong(
773         ATTR_PREFIX_COMMON_POOL +
774         ATTR_SUFFIX_SUCCESSFUL_CHECKOUTS_WITHOUT_WAITING);
775    commonPoolNumSuccessfulCheckoutsAfterWaiting = getLong(
776         ATTR_PREFIX_COMMON_POOL +
777         ATTR_SUFFIX_SUCCESSFUL_CHECKOUTS_AFTER_WAITING);
778    commonPoolNumSuccessfulCheckoutsNewConnection = getLong(
779         ATTR_PREFIX_COMMON_POOL + ATTR_SUFFIX_SUCCESSFUL_CHECKOUTS_NEW_CONN);
780    commonPoolNumFailedCheckouts = getLong(ATTR_PREFIX_COMMON_POOL +
781         ATTR_SUFFIX_FAILED_CHECKOUTS);
782    commonPoolNumReleasedValid = getLong(ATTR_PREFIX_COMMON_POOL +
783         ATTR_SUFFIX_RELEASED_VALID);
784
785    nonBindPoolAvailableConnections = getLong(ATTR_PREFIX_NONBIND_POOL +
786         ATTR_SUFFIX_AVAILABLE_CONNS);
787    nonBindPoolMaxAvailableConnections = getLong(ATTR_PREFIX_NONBIND_POOL +
788         ATTR_SUFFIX_MAX_AVAILABLE_CONNS);
789    nonBindPoolNumSuccessfulConnectionAttempts = getLong(
790         ATTR_PREFIX_NONBIND_POOL + ATTR_SUFFIX_SUCCESSFUL_CONNECTS);
791    nonBindPoolNumFailedConnectionAttempts = getLong(ATTR_PREFIX_NONBIND_POOL +
792         ATTR_SUFFIX_FAILED_CONNECTS);
793    nonBindPoolNumClosedDefunct = getLong(ATTR_PREFIX_NONBIND_POOL +
794         ATTR_SUFFIX_CLOSED_DEFUNCT);
795    nonBindPoolNumClosedExpired = getLong(ATTR_PREFIX_NONBIND_POOL +
796         ATTR_SUFFIX_CLOSED_EXPIRED);
797    nonBindPoolNumClosedUnneeded = getLong(ATTR_PREFIX_NONBIND_POOL +
798         ATTR_SUFFIX_CLOSED_UNNEEDED);
799    nonBindPoolNumSuccessfulCheckouts = getLong(ATTR_PREFIX_NONBIND_POOL +
800         ATTR_SUFFIX_SUCCESSFUL_CHECKOUTS);
801    nonBindPoolNumSuccessfulCheckoutsWithoutWaiting = getLong(
802         ATTR_PREFIX_NONBIND_POOL +
803         ATTR_SUFFIX_SUCCESSFUL_CHECKOUTS_WITHOUT_WAITING);
804    nonBindPoolNumSuccessfulCheckoutsAfterWaiting = getLong(
805         ATTR_PREFIX_NONBIND_POOL +
806         ATTR_SUFFIX_SUCCESSFUL_CHECKOUTS_AFTER_WAITING);
807    nonBindPoolNumSuccessfulCheckoutsNewConnection = getLong(
808         ATTR_PREFIX_NONBIND_POOL + ATTR_SUFFIX_SUCCESSFUL_CHECKOUTS_NEW_CONN);
809    nonBindPoolNumFailedCheckouts = getLong(ATTR_PREFIX_NONBIND_POOL +
810         ATTR_SUFFIX_FAILED_CHECKOUTS);
811    nonBindPoolNumReleasedValid = getLong(ATTR_PREFIX_NONBIND_POOL +
812         ATTR_SUFFIX_RELEASED_VALID);
813
814    final String hcStateStr = getString(ATTR_HEALTH_CHECK_STATE);
815    if (hcStateStr == null)
816    {
817      healthCheckState = null;
818    }
819    else
820    {
821      healthCheckState = HealthCheckState.forName(hcStateStr);
822    }
823  }
824
825
826
827  /**
828   * Retrieves the address of the LDAP external server.
829   *
830   * @return  The address of the LDAP external server, or {@code null} if it was
831   *          not included in the monitor entry.
832   */
833  public String getServerAddress()
834  {
835    return serverAddress;
836  }
837
838
839
840  /**
841   * Retrieves the port of the LDAP external server.
842   *
843   * @return  The port of the LDAP external server, or {@code null} if it was
844   *          not included in the monitor entry.
845   */
846  public Long getServerPort()
847  {
848    return serverPort;
849  }
850
851
852
853  /**
854   * Retrieves the communication security mechanism used when communicating with
855   * the external server.
856   *
857   * @return  The communication security mechanism used when communicating with
858   *          the external server, or {@code null} if it was not included in the
859   *          monitor entry.
860   */
861  public String getCommunicationSecurity()
862  {
863    return communicationSecurity;
864  }
865
866
867
868  /**
869   * Retrieves the DN of the configuration entry for the load-balancing
870   * algorithm that uses the LDAP external server.
871   *
872   * @return  The DN of the configuration entry for the load-balancing algorithm
873   *          that uses the LDAP external server, or {@code null} if it was not
874   *          included in the monitor entry.
875   */
876  public String getLoadBalancingAlgorithmDN()
877  {
878    return loadBalancingAlgorithmDN;
879  }
880
881
882
883  /**
884   * Retrieves the health check state for the LDAP external server.
885   *
886   * @return  The health check state for the LDAP external server, or
887   *          {@code null} if it was not included in the monitor entry.
888   */
889  public HealthCheckState getHealthCheckState()
890  {
891    return healthCheckState;
892  }
893
894
895
896  /**
897   * Retrieves the health check score for the LDAP external server.
898   *
899   * @return  The health check score for the LDAP external server, or
900   *          {@code null} if it was not included in the monitor entry.
901   */
902  public Long getHealthCheckScore()
903  {
904    return healthCheckScore;
905  }
906
907
908
909  /**
910   * Retrieves the list of health check messages for the LDAP external server.
911   *
912   * @return  The list of health check messages for the LDAP external server, or
913   *          an empty list if it was not included in the monitor entry.
914   */
915  public List<String> getHealthCheckMessages()
916  {
917    return healthCheckMessages;
918  }
919
920
921
922  /**
923   * Retrieves the time the health check information was last updated for the
924   * LDAP external server.
925   *
926   * @return  The time the health check information was last updated for the
927   *          LDAP external server, or {@code null} if it was not included in
928   *          the monitor entry.
929   */
930  public Date getHealthCheckUpdateTime()
931  {
932    return healthCheckUpdateTime;
933  }
934
935
936
937  /**
938   * Retrieves the total number of add operations attempted against the LDAP
939   * external server.
940   *
941   * @return  The total number of add operations attempted against the LDAP
942   *          external server, or {@code null} if it was not included in the
943   *          monitor entry.
944   */
945  public Long getAddAttempts()
946  {
947    return addAttempts;
948  }
949
950
951
952  /**
953   * Retrieves the number of failed add attempts against the LDAP external
954   * server.
955   *
956   * @return  The number of failed add attempts against the LDAP external
957   *          server, or {@code null} if it was not included in the monitor
958   *          entry.
959   */
960  public Long getAddFailures()
961  {
962    return addFailures;
963  }
964
965
966
967  /**
968   * Retrieves the number of successful add attempts against the LDAP external
969   * server.
970   *
971   * @return  The number of successful add attempts against the LDAP external
972   *          server, or {@code null} if it was not included in the monitor
973   *          entry.
974   */
975  public Long getAddSuccesses()
976  {
977    return addSuccesses;
978  }
979
980
981
982  /**
983   * Retrieves the total number of bind operations attempted against the LDAP
984   * external server.
985   *
986   * @return  The total number of bind operations attempted against the LDAP
987   *          external server, or {@code null} if it was not included in the
988   *          monitor entry.
989   */
990  public Long getBindAttempts()
991  {
992    return bindAttempts;
993  }
994
995
996
997  /**
998   * Retrieves the number of failed bind attempts against the LDAP external
999   * server.
1000   *
1001   * @return  The number of failed bind attempts against the LDAP external
1002   *          server, or {@code null} if it was not included in the monitor
1003   *          entry.
1004   */
1005  public Long getBindFailures()
1006  {
1007    return bindFailures;
1008  }
1009
1010
1011
1012  /**
1013   * Retrieves the number of successful bind attempts against the LDAP external
1014   * server.
1015   *
1016   * @return  The number of successful bind attempts against the LDAP external
1017   *          server, or {@code null} if it was not included in the monitor
1018   *          entry.
1019   */
1020  public Long getBindSuccesses()
1021  {
1022    return bindSuccesses;
1023  }
1024
1025
1026
1027  /**
1028   * Retrieves the total number of compare operations attempted against the LDAP
1029   * external server.
1030   *
1031   * @return  The total number of compare operations attempted against the LDAP
1032   *          external server, or {@code null} if it was not included in the
1033   *          monitor entry.
1034   */
1035  public Long getCompareAttempts()
1036  {
1037    return compareAttempts;
1038  }
1039
1040
1041
1042  /**
1043   * Retrieves the number of failed compare attempts against the LDAP external
1044   * server.
1045   *
1046   * @return  The number of failed compare attempts against the LDAP external
1047   *          server, or {@code null} if it was not included in the monitor
1048   *          entry.
1049   */
1050  public Long getCompareFailures()
1051  {
1052    return compareFailures;
1053  }
1054
1055
1056
1057  /**
1058   * Retrieves the number of successful compare attempts against the LDAP
1059   * external server.
1060   *
1061   * @return  The number of successful compare attempts against the LDAP
1062   *          external server, or {@code null} if it was not included in the
1063   *          monitor entry.
1064   */
1065  public Long getCompareSuccesses()
1066  {
1067    return compareSuccesses;
1068  }
1069
1070
1071
1072  /**
1073   * Retrieves the total number of delete operations attempted against the LDAP
1074   * external server.
1075   *
1076   * @return  The total number of delete operations attempted against the LDAP
1077   *          external server, or {@code null} if it was not included in the
1078   *          monitor entry.
1079   */
1080  public Long getDeleteAttempts()
1081  {
1082    return deleteAttempts;
1083  }
1084
1085
1086
1087  /**
1088   * Retrieves the number of failed delete attempts against the LDAP external
1089   * server.
1090   *
1091   * @return  The number of failed delete attempts against the LDAP external
1092   *          server, or {@code null} if it was not included in the monitor
1093   *          entry.
1094   */
1095  public Long getDeleteFailures()
1096  {
1097    return deleteFailures;
1098  }
1099
1100
1101
1102  /**
1103   * Retrieves the number of successful delete attempts against the LDAP
1104   * external server.
1105   *
1106   * @return  The number of successful delete attempts against the LDAP
1107   *          external server, or {@code null} if it was not included in the
1108   *          monitor entry.
1109   */
1110  public Long getDeleteSuccesses()
1111  {
1112    return deleteSuccesses;
1113  }
1114
1115
1116
1117  /**
1118   * Retrieves the total number of modify operations attempted against the LDAP
1119   * external server.
1120   *
1121   * @return  The total number of modify operations attempted against the LDAP
1122   *          external server, or {@code null} if it was not included in the
1123   *          monitor entry.
1124   */
1125  public Long getModifyAttempts()
1126  {
1127    return modifyAttempts;
1128  }
1129
1130
1131
1132  /**
1133   * Retrieves the number of failed modify attempts against the LDAP external
1134   * server.
1135   *
1136   * @return  The number of failed modify attempts against the LDAP external
1137   *          server, or {@code null} if it was not included in the monitor
1138   *          entry.
1139   */
1140  public Long getModifyFailures()
1141  {
1142    return modifyFailures;
1143  }
1144
1145
1146
1147  /**
1148   * Retrieves the number of successful modify attempts against the LDAP
1149   * external server.
1150   *
1151   * @return  The number of successful modify attempts against the LDAP
1152   *          external server, or {@code null} if it was not included in the
1153   *          monitor entry.
1154   */
1155  public Long getModifySuccesses()
1156  {
1157    return modifySuccesses;
1158  }
1159
1160
1161
1162  /**
1163   * Retrieves the total number of modify DN operations attempted against the
1164   * LDAP external server.
1165   *
1166   * @return  The total number of modify DN operations attempted against the
1167   *          LDAP external server, or {@code null} if it was not included in
1168   *          the monitor entry.
1169   */
1170  public Long getModifyDNAttempts()
1171  {
1172    return modifyDNAttempts;
1173  }
1174
1175
1176
1177  /**
1178   * Retrieves the number of failed modify DN attempts against the LDAP external
1179   * server.
1180   *
1181   * @return  The number of failed modify DN attempts against the LDAP external
1182   *          server, or {@code null} if it was not included in the monitor
1183   *          entry.
1184   */
1185  public Long getModifyDNFailures()
1186  {
1187    return modifyDNFailures;
1188  }
1189
1190
1191
1192  /**
1193   * Retrieves the number of successful modify DN attempts against the LDAP
1194   * external server.
1195   *
1196   * @return  The number of successful modify DN attempts against the LDAP
1197   *          external server, or {@code null} if it was not included in the
1198   *          monitor entry.
1199   */
1200  public Long getModifyDNSuccesses()
1201  {
1202    return modifyDNSuccesses;
1203  }
1204
1205
1206
1207  /**
1208   * Retrieves the total number of search operations attempted against the LDAP
1209   * external server.
1210   *
1211   * @return  The total number of search operations attempted against the LDAP
1212   *          external server, or {@code null} if it was not included in the
1213   *          monitor entry.
1214   */
1215  public Long getSearchAttempts()
1216  {
1217    return searchAttempts;
1218  }
1219
1220
1221
1222  /**
1223   * Retrieves the number of failed search attempts against the LDAP external
1224   * server.
1225   *
1226   * @return  The number of failed search attempts against the LDAP external
1227   *          server, or {@code null} if it was not included in the monitor
1228   *          entry.
1229   */
1230  public Long getSearchFailures()
1231  {
1232    return searchFailures;
1233  }
1234
1235
1236
1237  /**
1238   * Retrieves the number of successful search attempts against the LDAP
1239   * external server.
1240   *
1241   * @return  The number of successful search attempts against the LDAP
1242   *          external server, or {@code null} if it was not included in the
1243   *          monitor entry.
1244   */
1245  public Long getSearchSuccesses()
1246  {
1247    return searchSuccesses;
1248  }
1249
1250
1251
1252  /**
1253   * Retrieves the number of currently available connections in the common
1254   * connection pool used by the LDAP external server used for both bind and
1255   * non-bind operations.
1256   *
1257   * @return  The number of currently available connections in the common
1258   *          connection pool used by the LDAP external server used for both
1259   *          bind and non-bind operations, or {@code null} if it was not
1260   *          included in the monitor entry or if the external server uses
1261   *          separate pools for bind and non-bind operations.
1262   */
1263  public Long getCommonPoolAvailableConnections()
1264  {
1265    return commonPoolAvailableConnections;
1266  }
1267
1268
1269
1270  /**
1271   * Retrieves the maximum number of connections that may be available in the
1272   * common connection pool used by the LDAP external server for both bind and
1273   * non-bind operations.
1274   *
1275   * @return  The maximum number of connections that may be available in the
1276   *          common connection pool used by the LDAP external server for both
1277   *          bind and non-bind operations, or {@code null} if it was not
1278   *          included in the monitor entry or if the external server uses
1279   *          separate pools for bind and non-bind operations.
1280   */
1281  public Long getCommonPoolMaxAvailableConnections()
1282  {
1283    return commonPoolMaxAvailableConnections;
1284  }
1285
1286
1287
1288  /**
1289   * Retrieves the number of successful connection attempts in the common
1290   * connection pool used by the LDAP external server for both bind and non-bind
1291   * operations.
1292   *
1293   * @return  The number of successful connection attempts in the common
1294   *          connection pool used by the LDAP external server for both bind and
1295   *          non-bind operations, or {@code null} if it was not included in the
1296   *          monitor entry or if the external server uses separate pools for
1297   *          bind and non-bind operations.
1298   */
1299  public Long getCommonPoolNumSuccessfulConnectionAttempts()
1300  {
1301    return commonPoolNumSuccessfulConnectionAttempts;
1302  }
1303
1304
1305
1306  /**
1307   * Retrieves the number of failed connection attempts in the common connection
1308   * pool used by the LDAP external server for both bind and non-bind
1309   * operations.
1310   *
1311   * @return  The number of failed connection attempts in the common connection
1312   *          pool used by the LDAP external server for both bind and non-bind
1313   *          operations, or {@code null} if it was not included in the monitor
1314   *          entry or if the external server uses separate pools for bind and
1315   *          non-bind operations.
1316   */
1317  public Long getCommonPoolNumFailedConnectionAttempts()
1318  {
1319    return commonPoolNumFailedConnectionAttempts;
1320  }
1321
1322
1323
1324  /**
1325   * Retrieves the number of connections in the common connection pool used by
1326   * the LDAP external server for both bind and non-bind operations that have
1327   * been closed as defunct.
1328   *
1329   * @return  The number of connections in the common connection pool used by
1330   *          the LDAP external server for both bind and non-bind operations
1331   *          that have been closed as defunct, or {@code null} if it was not
1332   *          included in the monitor entry or if the external server uses
1333   *          separate pools for bind and non-bind operations.
1334   */
1335  public Long getCommonPoolNumClosedDefunct()
1336  {
1337    return commonPoolNumClosedDefunct;
1338  }
1339
1340
1341
1342  /**
1343   * Retrieves the number of connections in the common connection pool used by
1344   * the LDAP external server for processing both bind and non-bind operations
1345   * that have been closed as expired.
1346   *
1347   * @return  The number of connections in the common connection pool used by
1348   *          the LDAP external server for both bind and non-bind operations
1349   *          that have been closed as expired, or {@code null} if it was not
1350   *          included in the monitor entry or if the external server uses
1351   *          separate pools for bind and non-bind operations.
1352   */
1353  public Long getCommonPoolNumClosedExpired()
1354  {
1355    return commonPoolNumClosedExpired;
1356  }
1357
1358
1359
1360  /**
1361   * Retrieves the number of connections in the common connection pool used by
1362   * the LDAP external server for both bind and non-bind operations that have
1363   * been closed as unneeded.
1364   *
1365   * @return  The number of connections in the common connection pool used by
1366   *          the LDAP external server for both bind and non-bind operations
1367   *          that have been closed as unneeded, or {@code null} if it was not
1368   *          included in the monitor entry or if the external server uses
1369   *          separate pools for bind and non-bind operations.
1370   */
1371  public Long getCommonPoolNumClosedUnneeded()
1372  {
1373    return commonPoolNumClosedUnneeded;
1374  }
1375
1376
1377
1378  /**
1379   * Retrieves the total number of successful checkouts from the common
1380   * connection pool used by the LDAP external server for both bind and non-bind
1381   * operations.
1382   *
1383   * @return  The total number of successful checkouts from the common
1384   *          connection pool used by the LDAP external server for both bind and
1385   *          non-bind operations, or {@code null} if it was not included in the
1386   *          monitor entry or if the external server uses separate pools for
1387   *          bind and non-bind operations.
1388   */
1389  public Long getCommonPoolTotalSuccessfulCheckouts()
1390  {
1391    return commonPoolNumSuccessfulCheckouts;
1392  }
1393
1394
1395
1396  /**
1397   * Retrieves the number of successful checkouts from the common connection
1398   * pool used by the LDAP external server for both bind and non-bind operations
1399   * in which an existing connection was retrieved without needing to wait.
1400   *
1401   * @return  The number of successful checkouts from the common connection pool
1402   *          used by the LDAP external server for both bind and non-bind
1403   *          operations in which an existing connection was retrieved without
1404   *          needing to wait, or {@code null} if it was not included in the
1405   *          monitor entry or if the external server uses separate pools for
1406   *          bind and non-bind operations.
1407   */
1408  public Long getCommonPoolNumSuccessfulCheckoutsWithoutWaiting()
1409  {
1410    return commonPoolNumSuccessfulCheckoutsWithoutWaiting;
1411  }
1412
1413
1414
1415  /**
1416   * Retrieves the number of successful checkouts from the common connection
1417   * pool used by the LDAP external server for both bind and non-bind operations
1418   * in which an existing connection was retrieved after waiting for the
1419   * connection to become available.
1420   *
1421   * @return  The number of successful checkouts from the common connection pool
1422   *          used by the LDAP external server for both bind and non-bind
1423   *          operations in which an existing connection was retrieved after
1424   *          waiting for the connection to become available, or {@code null} if
1425   *          it was not included in the monitor entry or if the external server
1426   *          uses separate pools for bind and non-bind operations.
1427   */
1428  public Long getCommonPoolNumSuccessfulCheckoutsAfterWaiting()
1429  {
1430    return commonPoolNumSuccessfulCheckoutsAfterWaiting;
1431  }
1432
1433
1434
1435  /**
1436   * Retrieves the number of successful checkouts from the common connection
1437   * pool used by the LDAP external server for both bind and non-bind operations
1438   * in which an existing connection was retrieved after creating a new
1439   * connection.
1440   *
1441   * @return  The number of successful checkouts from the common connection pool
1442   *          used by the LDAP external server for both bind and non-bind
1443   *          operations in which an existing connection was retrieved after
1444   *          creating a new connection, or {@code null} if it was not included
1445   *          in the monitor entry or if the external server uses separate pools
1446   *          for bind and non-bind operations.
1447   */
1448  public Long getCommonPoolNumSuccessfulCheckoutsNewConnection()
1449  {
1450    return commonPoolNumSuccessfulCheckoutsNewConnection;
1451  }
1452
1453
1454
1455  /**
1456   * Retrieves the number of failed checkout attempts from the common connection
1457   * pool used by the LDAP external server for both bind and non-bind
1458   * operations.
1459   *
1460   * @return  The number of failed checkout attempts from the common connection
1461   *          pool used by the LDAP external server for both bind and non-bind
1462   *          operations, or {@code null} if it was not included in the monitor
1463   *          entry or if the external server uses separate pools for bind and
1464   *          non-bind operations.
1465   */
1466  public Long getCommonPoolNumFailedCheckouts()
1467  {
1468    return commonPoolNumFailedCheckouts;
1469  }
1470
1471
1472
1473  /**
1474   * Retrieves the number of connections released as valid back to the common
1475   * connection pool used by the LDAP external server for bind and non-bind
1476   * operations.
1477   *
1478   * @return  The number of connections released as valid back to the common
1479   *          connection pool used by the LDAP external server used for bind and
1480   *          non-bind operations, or {@code null} if it was not included in the
1481   *          monitor entry or if the external server uses a separate pools for
1482   *          bind and non-bind operations.
1483   */
1484  public Long getCommonPoolNumReleasedValid()
1485  {
1486    return commonPoolNumReleasedValid;
1487  }
1488
1489
1490
1491  /**
1492   * Retrieves the number of currently available connections in the bind
1493   * connection pool used by the LDAP external server.
1494   *
1495   * @return  The number of currently available connections in the bind
1496   *          connection pool used by the LDAP external server, or {@code null}
1497   *          if it was not included in the monitor entry or if the external
1498   *          server uses a common pool for bind and non-bind operations.
1499   */
1500  public Long getBindPoolAvailableConnections()
1501  {
1502    return bindPoolAvailableConnections;
1503  }
1504
1505
1506
1507  /**
1508   * Retrieves the maximum number of connections that may be available in the
1509   * bind connection pool used by the LDAP external server.
1510   *
1511   * @return  The maximum number of connections that may be available in the
1512   *          bind connection pool used by the LDAP external server, or
1513   *          {@code null} if it was not included in the monitor entry or if the
1514   *          external server uses a common pool for bind and non-bind
1515   *          operations.
1516   */
1517  public Long getBindPoolMaxAvailableConnections()
1518  {
1519    return bindPoolMaxAvailableConnections;
1520  }
1521
1522
1523
1524  /**
1525   * Retrieves the number of successful connection attempts in the bind
1526   * connection pool used by the LDAP external server.
1527   *
1528   * @return  The number of successful connection attempts in the bind
1529   *          connection pool used by the LDAP external server, or {@code null}
1530   *          if it was not included in the monitor entry or if the external
1531   *          server uses a common pool for bind and non-bind operations.
1532   */
1533  public Long getBindPoolNumSuccessfulConnectionAttempts()
1534  {
1535    return bindPoolNumSuccessfulConnectionAttempts;
1536  }
1537
1538
1539
1540  /**
1541   * Retrieves the number of failed connection attempts in the bind connection
1542   * pool used by the LDAP external server.
1543   *
1544   * @return  The number of failed connection attempts in the bind connection
1545   *          pool used by the LDAP external server, or {@code null} if it was
1546   *          not included in the monitor entry or if the external server uses a
1547   *          common pool for bind and non-bind operations.
1548   */
1549  public Long getBindPoolNumFailedConnectionAttempts()
1550  {
1551    return bindPoolNumFailedConnectionAttempts;
1552  }
1553
1554
1555
1556  /**
1557   * Retrieves the number of connections in the bind connection pool used by the
1558   * LDAP external server that have been closed as defunct.
1559   *
1560   * @return  The number of connections in the bind connection pool used by the
1561   *          LDAP external server that have been closed as defunct, or
1562   *          {@code null} if it was not included in the monitor entry or if the
1563   *          external server uses a common pool for bind and non-bind
1564   *          operations.
1565   */
1566  public Long getBindPoolNumClosedDefunct()
1567  {
1568    return bindPoolNumClosedDefunct;
1569  }
1570
1571
1572
1573  /**
1574   * Retrieves the number of connections in the bind connection pool used by the
1575   * LDAP external server that have been closed as expired.
1576   *
1577   * @return  The number of connections in the bind connection pool used by the
1578   *          LDAP external server that have been closed as expired, or
1579   *          {@code null} if it was not included in the monitor entry or if the
1580   *          external server uses a common pool for bind and non-bind
1581   *          operations.
1582   */
1583  public Long getBindPoolNumClosedExpired()
1584  {
1585    return bindPoolNumClosedExpired;
1586  }
1587
1588
1589
1590  /**
1591   * Retrieves the number of connections in the bind connection pool used by the
1592   * LDAP external server that have been closed as unneeded.
1593   *
1594   * @return  The number of connections in the bind connection pool used by the
1595   *          LDAP external server that have been closed as unneeded, or
1596   *          {@code null} if it was not included in the monitor entry or if the
1597   *          external server uses a common pool for bind and non-bind
1598   *          operations.
1599   */
1600  public Long getBindPoolNumClosedUnneeded()
1601  {
1602    return bindPoolNumClosedUnneeded;
1603  }
1604
1605
1606
1607  /**
1608   * Retrieves the total number of successful checkouts from the bind connection
1609   * pool used by the LDAP external server.
1610   *
1611   * @return  The total number of successful checkouts from the bind connection
1612   *          pool used by the LDAP external server, or {@code null} if it was
1613   *          not included in the monitor entry or if the external server uses a
1614   *          common pool for bind and non-bind operations.
1615   */
1616  public Long getBindPoolTotalSuccessfulCheckouts()
1617  {
1618    return bindPoolNumSuccessfulCheckouts;
1619  }
1620
1621
1622
1623  /**
1624   * Retrieves the number of successful checkouts from the bind connection pool
1625   * used by the LDAP external server in which an existing connection was
1626   * retrieved without needing to wait.
1627   *
1628   * @return  The number of successful checkouts from the bind connection pool
1629   *          used by the LDAP external server in which an existing connection
1630   *          was retrieved without needing to wait, or {@code null} if it was
1631   *          not included in the monitor entry or if the external server uses a
1632   *          common pool for bind and non-bind operations.
1633   */
1634  public Long getBindPoolNumSuccessfulCheckoutsWithoutWaiting()
1635  {
1636    return bindPoolNumSuccessfulCheckoutsWithoutWaiting;
1637  }
1638
1639
1640
1641  /**
1642   * Retrieves the number of successful checkouts from the bind connection pool
1643   * used by the LDAP external server in which an existing connection was
1644   * retrieved after waiting for the connection to become available.
1645   *
1646   * @return  The number of successful checkouts from the bind connection pool
1647   *          used by the LDAP external server in which an existing connection
1648   *          was retrieved after waiting for the connection to become
1649   *          available, or {@code null} if it was not included in the monitor
1650   *          entry or if the external server uses a common pool for bind and
1651   *          non-bind operations.
1652   */
1653  public Long getBindPoolNumSuccessfulCheckoutsAfterWaiting()
1654  {
1655    return bindPoolNumSuccessfulCheckoutsAfterWaiting;
1656  }
1657
1658
1659
1660  /**
1661   * Retrieves the number of successful checkouts from the bind connection pool
1662   * used by the LDAP external server in which an existing connection was
1663   * retrieved after creating a new connection.
1664   *
1665   * @return  The number of successful checkouts from the bind connection pool
1666   *          used by the LDAP external server in which an existing connection
1667   *          was retrieved after creating a new connection, or {@code null} if
1668   *          it was not included in the monitor entry or if the external server
1669   *          uses a common pool for bind and non-bind operations.
1670   */
1671  public Long getBindPoolNumSuccessfulCheckoutsNewConnection()
1672  {
1673    return bindPoolNumSuccessfulCheckoutsNewConnection;
1674  }
1675
1676
1677
1678  /**
1679   * Retrieves the number of failed checkout attempts from the bind connection
1680   * pool used by the LDAP external server.
1681   *
1682   * @return  The number of failed checkout attempts from the bind connection
1683   *          pool used by the LDAP external server, or {@code null} if it was
1684   *          not included in the monitor entry or if the external server uses a
1685   *          common pool for bind and non-bind operations.
1686   */
1687  public Long getBindPoolNumFailedCheckouts()
1688  {
1689    return bindPoolNumFailedCheckouts;
1690  }
1691
1692
1693
1694  /**
1695   * Retrieves the number of connections released as valid back to the bind
1696   * connection pool used by the LDAP external server.
1697   *
1698   * @return  The number of connections released as valid back to the bind
1699   *          connection pool used by the LDAP external server, or {@code null}
1700   *          if it was not included in the monitor entry or if the external
1701   *          server uses a common pool for bind and non-bind operations.
1702   */
1703  public Long getBindPoolNumReleasedValid()
1704  {
1705    return bindPoolNumReleasedValid;
1706  }
1707
1708
1709
1710  /**
1711   * Retrieves the number of currently available connections in the non-bind
1712   * connection pool used by the LDAP external server.
1713   *
1714   * @return  The number of currently available connections in the non-bind
1715   *          connection pool used by the LDAP external server, or {@code null}
1716   *          if it was not included in the monitor entry or if the external
1717   *          server uses a common pool for bind and non-bind operations.
1718   */
1719  public Long getNonBindPoolAvailableConnections()
1720  {
1721    return nonBindPoolAvailableConnections;
1722  }
1723
1724
1725
1726  /**
1727   * Retrieves the maximum number of connections that may be available in the
1728   * non-bind connection pool used by the LDAP external server.
1729   *
1730   * @return  The maximum number of connections that may be available in the
1731   *          non-bind connection pool used by the LDAP external server, or
1732   *          {@code null} if it was not included in the monitor entry or if the
1733   *          external server uses a common pool for bind and non-bind
1734   *          operations.
1735   */
1736  public Long getNonBindPoolMaxAvailableConnections()
1737  {
1738    return nonBindPoolMaxAvailableConnections;
1739  }
1740
1741
1742
1743  /**
1744   * Retrieves the number of successful connection attempts in the non-bind
1745   * connection pool used by the LDAP external server.
1746   *
1747   * @return  The number of successful connection attempts in the non-bind
1748   *          connection pool used by the LDAP external server, or {@code null}
1749   *          if it was not included in the monitor entry or if the external
1750   *          server uses a common pool for bind and non-bind operations.
1751   */
1752  public Long getNonBindPoolNumSuccessfulConnectionAttempts()
1753  {
1754    return nonBindPoolNumSuccessfulConnectionAttempts;
1755  }
1756
1757
1758
1759  /**
1760   * Retrieves the number of failed connection attempts in the non-bind
1761   * connection pool used by the LDAP external server.
1762   *
1763   * @return  The number of failed connection attempts in the non-bind
1764   *          connection pool used by the LDAP external server, or {@code null}
1765   *          if it was not included in the monitor entry or if the external
1766   *          server uses a common pool for bind and non-bind operations.
1767   */
1768  public Long getNonBindPoolNumFailedConnectionAttempts()
1769  {
1770    return nonBindPoolNumFailedConnectionAttempts;
1771  }
1772
1773
1774
1775  /**
1776   * Retrieves the number of connections in the non-bind connection pool used by
1777   * the LDAP external server that have been closed as defunct.
1778   *
1779   * @return  The number of connections in the non-bind connection pool used by
1780   *          the LDAP external server that have been closed as defunct, or
1781   *          {@code null} if it was not included in the monitor entry or if the
1782   *          external server uses a common pool for bind and non-bind
1783   *          operations.
1784   */
1785  public Long getNonBindPoolNumClosedDefunct()
1786  {
1787    return nonBindPoolNumClosedDefunct;
1788  }
1789
1790
1791
1792  /**
1793   * Retrieves the number of connections in the non-bind connection pool used by
1794   * the LDAP external server that have been closed as expired.
1795   *
1796   * @return  The number of connections in the non-bind connection pool used by
1797   *          the LDAP external server that have been closed as expired, or
1798   *          {@code null} if it was not included in the monitor entry or if the
1799   *          external server uses a common pool for bind and non-bind
1800   *          operations.
1801   */
1802  public Long getNonBindPoolNumClosedExpired()
1803  {
1804    return nonBindPoolNumClosedExpired;
1805  }
1806
1807
1808
1809  /**
1810   * Retrieves the number of connections in the non-bind connection pool used by
1811   * the LDAP external server that have been closed as unneeded.
1812   *
1813   * @return  The number of connections in the non-bind connection pool used by
1814   *          the LDAP external server that have been closed as unneeded, or
1815   *          {@code null} if it was not included in the monitor entry or if the
1816   *          external server uses a common pool for bind and non-bind
1817   *          operations.
1818   */
1819  public Long getNonBindPoolNumClosedUnneeded()
1820  {
1821    return nonBindPoolNumClosedUnneeded;
1822  }
1823
1824
1825
1826  /**
1827   * Retrieves the total number of successful checkouts from the non-bind
1828   * connection pool used by the LDAP external server.
1829   *
1830   * @return  The total number of successful checkouts from the non-bind
1831   *          connection pool used by the LDAP external server, or {@code null}
1832   *          if it was not included in the monitor entry or if the external
1833   *          server uses a common pool for bind and non-bind operations.
1834   */
1835  public Long getNonBindPoolTotalSuccessfulCheckouts()
1836  {
1837    return nonBindPoolNumSuccessfulCheckouts;
1838  }
1839
1840
1841
1842  /**
1843   * Retrieves the number of successful checkouts from the non-bind connection
1844   * pool used by the LDAP external server in which an existing connection was
1845   * retrieved without needing to wait.
1846   *
1847   * @return  The number of successful checkouts from the non-bind connection
1848   *          pool used by the LDAP external server in which an existing
1849   *          connection was retrieved without needing to wait, or {@code null}
1850   *          if it was not included in the monitor entry or if the external
1851   *          server uses a common pool for bind and non-bind operations.
1852   */
1853  public Long getNonBindPoolNumSuccessfulCheckoutsWithoutWaiting()
1854  {
1855    return nonBindPoolNumSuccessfulCheckoutsWithoutWaiting;
1856  }
1857
1858
1859
1860  /**
1861   * Retrieves the number of successful checkouts from the non-bind connection
1862   * pool used by the LDAP external server in which an existing connection was
1863   * retrieved after waiting for the connection to become available.
1864   *
1865   * @return  The number of successful checkouts from the non-bind connection
1866   *          pool used by the LDAP external server in which an existing
1867   *          connection was retrieved after waiting for the connection to
1868   *          become available, or {@code null} if it was not included in the
1869   *          monitor entry or if the external server uses a common pool for
1870   *          bind and non-bind operations.
1871   */
1872  public Long getNonBindPoolNumSuccessfulCheckoutsAfterWaiting()
1873  {
1874    return nonBindPoolNumSuccessfulCheckoutsAfterWaiting;
1875  }
1876
1877
1878
1879  /**
1880   * Retrieves the number of successful checkouts from the non-bind connection
1881   * pool used by the LDAP external server in which an existing connection was
1882   * retrieved after creating a new connection.
1883   *
1884   * @return  The number of successful checkouts from the non-bind connection
1885   *          pool used by the LDAP external server in which an existing
1886   *          connection was retrieved after creating a new connection, or
1887   *          {@code null} if it was not included in the monitor entry or if the
1888   *          external server uses a common pool for bind and non-bind
1889   *          operations.
1890   */
1891  public Long getNonBindPoolNumSuccessfulCheckoutsNewConnection()
1892  {
1893    return nonBindPoolNumSuccessfulCheckoutsNewConnection;
1894  }
1895
1896
1897
1898  /**
1899   * Retrieves the number of failed checkout attempts from the non-bind
1900   * connection pool used by the LDAP external server.
1901   *
1902   * @return  The number of failed checkout attempts from the non-bind
1903   *          connection pool used by the LDAP external server, or {@code null}
1904   *          if it was not included in the monitor entry or if the external
1905   *          server uses a common pool for bind and non-bind operations.
1906   */
1907  public Long getNonBindPoolNumFailedCheckouts()
1908  {
1909    return nonBindPoolNumFailedCheckouts;
1910  }
1911
1912
1913
1914  /**
1915   * Retrieves the number of connections released as valid back to the non-bind
1916   * connection pool used by the LDAP external server.
1917   *
1918   * @return  The number of connections released as valid back to the non-bind
1919   *          connection pool used by the LDAP external server, or {@code null}
1920   *          if it was not included in the monitor entry or if the external
1921   *          server uses a common pool for bind and non-bind operations.
1922   */
1923  public Long getNonBindPoolNumReleasedValid()
1924  {
1925    return nonBindPoolNumReleasedValid;
1926  }
1927
1928
1929
1930  /**
1931   * {@inheritDoc}
1932   */
1933  @Override()
1934  public String getMonitorDisplayName()
1935  {
1936    return INFO_LDAP_EXT_SERVER_MONITOR_DISPNAME.get();
1937  }
1938
1939
1940
1941  /**
1942   * {@inheritDoc}
1943   */
1944  @Override()
1945  public String getMonitorDescription()
1946  {
1947    return INFO_LDAP_EXT_SERVER_MONITOR_DESC.get();
1948  }
1949
1950
1951
1952  /**
1953   * {@inheritDoc}
1954   */
1955  @Override()
1956  public Map<String,MonitorAttribute> getMonitorAttributes()
1957  {
1958    final LinkedHashMap<String,MonitorAttribute> attrs =
1959         new LinkedHashMap<String,MonitorAttribute>();
1960
1961    if (serverAddress != null)
1962    {
1963      addMonitorAttribute(attrs,
1964           ATTR_SERVER_ADDRESS,
1965           INFO_LDAP_EXT_SERVER_DISPNAME_SERVER_ADDRESS.get(),
1966           INFO_LDAP_EXT_SERVER_DESC_SERVER_ADDRESS.get(),
1967           serverAddress);
1968    }
1969
1970    if (serverPort != null)
1971    {
1972      addMonitorAttribute(attrs,
1973           ATTR_SERVER_PORT,
1974           INFO_LDAP_EXT_SERVER_DISPNAME_SERVER_PORT.get(),
1975           INFO_LDAP_EXT_SERVER_DESC_SERVER_PORT.get(),
1976           serverPort);
1977    }
1978
1979    if (communicationSecurity != null)
1980    {
1981      addMonitorAttribute(attrs,
1982           ATTR_COMMUNICATION_SECURITY,
1983           INFO_LDAP_EXT_SERVER_DISPNAME_COMMUNICATION_SECURITY.get(),
1984           INFO_LDAP_EXT_SERVER_DESC_COMMUNICATION_SECURITY.get(),
1985           communicationSecurity);
1986    }
1987
1988    if (loadBalancingAlgorithmDN != null)
1989    {
1990      addMonitorAttribute(attrs,
1991           ATTR_LOAD_BALANCING_ALGORITHM_DN,
1992           INFO_LDAP_EXT_SERVER_DISPNAME_LOAD_BALANCING_ALGORITHM_DN.get(),
1993           INFO_LDAP_EXT_SERVER_DESC_LOAD_BALANCING_ALGORITHM_DN.get(),
1994           loadBalancingAlgorithmDN);
1995    }
1996
1997    if (healthCheckState != null)
1998    {
1999      addMonitorAttribute(attrs,
2000           ATTR_HEALTH_CHECK_STATE,
2001           INFO_LDAP_EXT_SERVER_DISPNAME_HEALTH_CHECK_STATE.get(),
2002           INFO_LDAP_EXT_SERVER_DESC_HEALTH_CHECK_STATE.get(),
2003           healthCheckState.getName());
2004    }
2005
2006    if (healthCheckScore != null)
2007    {
2008      addMonitorAttribute(attrs,
2009           ATTR_HEALTH_CHECK_SCORE,
2010           INFO_LDAP_EXT_SERVER_DISPNAME_HEALTH_CHECK_SCORE.get(),
2011           INFO_LDAP_EXT_SERVER_DESC_HEALTH_CHECK_SCORE.get(),
2012           healthCheckScore);
2013    }
2014
2015    if ((healthCheckMessages != null) && (! healthCheckMessages.isEmpty()))
2016    {
2017      addMonitorAttribute(attrs,
2018           ATTR_HEALTH_CHECK_MESSAGE,
2019           INFO_LDAP_EXT_SERVER_DISPNAME_HEALTH_CHECK_MESSAGE.get(),
2020           INFO_LDAP_EXT_SERVER_DESC_HEALTH_CHECK_MESSAGE.get(),
2021           healthCheckMessages);
2022    }
2023
2024    if (healthCheckUpdateTime != null)
2025    {
2026      addMonitorAttribute(attrs,
2027           ATTR_HEALTH_CHECK_UPDATE_TIME,
2028           INFO_LDAP_EXT_SERVER_DISPNAME_HEALTH_CHECK_UPDATE_TIME.get(),
2029           INFO_LDAP_EXT_SERVER_DESC_HEALTH_CHECK_UPDATE_TIME.get(),
2030           healthCheckUpdateTime);
2031    }
2032
2033    if (commonPoolAvailableConnections != null)
2034    {
2035      addMonitorAttribute(attrs,
2036           ATTR_PREFIX_COMMON_POOL + ATTR_SUFFIX_AVAILABLE_CONNS,
2037           INFO_LDAP_EXT_SERVER_DISPNAME_COMMON_AVAILABLE_CONNS.get(),
2038           INFO_LDAP_EXT_SERVER_DESC_COMMON_AVAILABLE_CONNS.get(),
2039           commonPoolAvailableConnections);
2040    }
2041
2042    if (commonPoolMaxAvailableConnections != null)
2043    {
2044      addMonitorAttribute(attrs,
2045           ATTR_PREFIX_COMMON_POOL + ATTR_SUFFIX_MAX_AVAILABLE_CONNS,
2046           INFO_LDAP_EXT_SERVER_DISPNAME_COMMON_MAX_AVAILABLE_CONNS.get(),
2047           INFO_LDAP_EXT_SERVER_DESC_COMMON_MAX_AVAILABLE_CONNS.get(),
2048           commonPoolMaxAvailableConnections);
2049    }
2050
2051    if (commonPoolNumSuccessfulConnectionAttempts != null)
2052    {
2053      addMonitorAttribute(attrs,
2054           ATTR_PREFIX_COMMON_POOL + ATTR_SUFFIX_SUCCESSFUL_CONNECTS,
2055           INFO_LDAP_EXT_SERVER_DISPNAME_COMMON_CONNECT_SUCCESS.get(),
2056           INFO_LDAP_EXT_SERVER_DESC_COMMON_CONNECT_SUCCESS.get(),
2057           commonPoolNumSuccessfulConnectionAttempts);
2058    }
2059
2060    if (commonPoolNumFailedConnectionAttempts != null)
2061    {
2062      addMonitorAttribute(attrs,
2063           ATTR_PREFIX_COMMON_POOL + ATTR_SUFFIX_FAILED_CONNECTS,
2064           INFO_LDAP_EXT_SERVER_DISPNAME_COMMON_CONNECT_FAILED.get(),
2065           INFO_LDAP_EXT_SERVER_DESC_COMMON_CONNECT_FAILED.get(),
2066           commonPoolNumFailedConnectionAttempts);
2067    }
2068
2069    if (commonPoolNumClosedDefunct != null)
2070    {
2071      addMonitorAttribute(attrs,
2072           ATTR_PREFIX_COMMON_POOL + ATTR_SUFFIX_CLOSED_DEFUNCT,
2073           INFO_LDAP_EXT_SERVER_DISPNAME_COMMON_CLOSED_DEFUNCT.get(),
2074           INFO_LDAP_EXT_SERVER_DESC_COMMON_CLOSED_DEFUNCT.get(),
2075           commonPoolNumClosedDefunct);
2076    }
2077
2078    if (commonPoolNumClosedExpired != null)
2079    {
2080      addMonitorAttribute(attrs,
2081           ATTR_PREFIX_COMMON_POOL + ATTR_SUFFIX_CLOSED_EXPIRED,
2082           INFO_LDAP_EXT_SERVER_DISPNAME_COMMON_CLOSED_EXPIRED.get(),
2083           INFO_LDAP_EXT_SERVER_DESC_COMMON_CLOSED_EXPIRED.get(),
2084           commonPoolNumClosedExpired);
2085    }
2086
2087    if (commonPoolNumClosedUnneeded != null)
2088    {
2089      addMonitorAttribute(attrs,
2090           ATTR_PREFIX_COMMON_POOL + ATTR_SUFFIX_CLOSED_UNNEEDED,
2091           INFO_LDAP_EXT_SERVER_DISPNAME_COMMON_CLOSED_UNNEEDED.get(),
2092           INFO_LDAP_EXT_SERVER_DESC_COMMON_CLOSED_UNNEEDED.get(),
2093           commonPoolNumClosedUnneeded);
2094    }
2095
2096    if (commonPoolNumSuccessfulCheckouts != null)
2097    {
2098      addMonitorAttribute(attrs,
2099           ATTR_PREFIX_COMMON_POOL + ATTR_SUFFIX_SUCCESSFUL_CHECKOUTS,
2100           INFO_LDAP_EXT_SERVER_DISPNAME_COMMON_CHECKOUT_SUCCESS.get(),
2101           INFO_LDAP_EXT_SERVER_DESC_COMMON_CHECKOUT_SUCCESS.get(),
2102           commonPoolNumSuccessfulCheckouts);
2103    }
2104
2105    if (commonPoolNumSuccessfulCheckoutsWithoutWaiting != null)
2106    {
2107      addMonitorAttribute(attrs,
2108           ATTR_PREFIX_COMMON_POOL +
2109                ATTR_SUFFIX_SUCCESSFUL_CHECKOUTS_WITHOUT_WAITING,
2110           INFO_LDAP_EXT_SERVER_DISPNAME_COMMON_CHECKOUT_NO_WAIT.get(),
2111           INFO_LDAP_EXT_SERVER_DESC_COMMON_CHECKOUT_NO_WAIT.get(),
2112           commonPoolNumSuccessfulCheckoutsWithoutWaiting);
2113    }
2114
2115    if (commonPoolNumSuccessfulCheckoutsAfterWaiting != null)
2116    {
2117      addMonitorAttribute(attrs,
2118           ATTR_PREFIX_COMMON_POOL +
2119                ATTR_SUFFIX_SUCCESSFUL_CHECKOUTS_AFTER_WAITING,
2120           INFO_LDAP_EXT_SERVER_DISPNAME_COMMON_CHECKOUT_WITH_WAIT.get(),
2121           INFO_LDAP_EXT_SERVER_DESC_COMMON_CHECKOUT_WITH_WAIT.get(),
2122           commonPoolNumSuccessfulCheckoutsAfterWaiting);
2123    }
2124
2125    if (commonPoolNumSuccessfulCheckoutsNewConnection != null)
2126    {
2127      addMonitorAttribute(attrs,
2128           ATTR_PREFIX_COMMON_POOL +
2129                ATTR_SUFFIX_SUCCESSFUL_CHECKOUTS_NEW_CONN,
2130           INFO_LDAP_EXT_SERVER_DISPNAME_COMMON_CHECKOUT_NEW_CONN.get(),
2131           INFO_LDAP_EXT_SERVER_DESC_COMMON_CHECKOUT_NEW_CONN.get(),
2132           commonPoolNumSuccessfulCheckoutsNewConnection);
2133    }
2134
2135    if (commonPoolNumFailedCheckouts != null)
2136    {
2137      addMonitorAttribute(attrs,
2138           ATTR_PREFIX_COMMON_POOL + ATTR_SUFFIX_FAILED_CHECKOUTS,
2139           INFO_LDAP_EXT_SERVER_DISPNAME_COMMON_CHECKOUT_FAILED.get(),
2140           INFO_LDAP_EXT_SERVER_DESC_COMMON_CHECKOUT_FAILED.get(),
2141           commonPoolNumFailedCheckouts);
2142    }
2143
2144    if (commonPoolNumReleasedValid != null)
2145    {
2146      addMonitorAttribute(attrs,
2147           ATTR_PREFIX_COMMON_POOL + ATTR_SUFFIX_RELEASED_VALID,
2148           INFO_LDAP_EXT_SERVER_DISPNAME_COMMON_RELEASED_VALID.get(),
2149           INFO_LDAP_EXT_SERVER_DESC_COMMON_RELEASED_VALID.get(),
2150           commonPoolNumReleasedValid);
2151    }
2152
2153    if (bindPoolAvailableConnections != null)
2154    {
2155      addMonitorAttribute(attrs,
2156           ATTR_PREFIX_BIND_POOL + ATTR_SUFFIX_AVAILABLE_CONNS,
2157           INFO_LDAP_EXT_SERVER_DISPNAME_BIND_AVAILABLE_CONNS.get(),
2158           INFO_LDAP_EXT_SERVER_DESC_BIND_AVAILABLE_CONNS.get(),
2159           bindPoolAvailableConnections);
2160    }
2161
2162    if (bindPoolMaxAvailableConnections != null)
2163    {
2164      addMonitorAttribute(attrs,
2165           ATTR_PREFIX_BIND_POOL + ATTR_SUFFIX_MAX_AVAILABLE_CONNS,
2166           INFO_LDAP_EXT_SERVER_DISPNAME_BIND_MAX_AVAILABLE_CONNS.get(),
2167           INFO_LDAP_EXT_SERVER_DESC_BIND_MAX_AVAILABLE_CONNS.get(),
2168           bindPoolMaxAvailableConnections);
2169    }
2170
2171    if (bindPoolNumSuccessfulConnectionAttempts != null)
2172    {
2173      addMonitorAttribute(attrs,
2174           ATTR_PREFIX_BIND_POOL + ATTR_SUFFIX_SUCCESSFUL_CONNECTS,
2175           INFO_LDAP_EXT_SERVER_DISPNAME_BIND_CONNECT_SUCCESS.get(),
2176           INFO_LDAP_EXT_SERVER_DESC_BIND_CONNECT_SUCCESS.get(),
2177           bindPoolNumSuccessfulConnectionAttempts);
2178    }
2179
2180    if (bindPoolNumFailedConnectionAttempts != null)
2181    {
2182      addMonitorAttribute(attrs,
2183           ATTR_PREFIX_BIND_POOL + ATTR_SUFFIX_FAILED_CONNECTS,
2184           INFO_LDAP_EXT_SERVER_DISPNAME_BIND_CONNECT_FAILED.get(),
2185           INFO_LDAP_EXT_SERVER_DESC_BIND_CONNECT_FAILED.get(),
2186           bindPoolNumFailedConnectionAttempts);
2187    }
2188
2189    if (bindPoolNumClosedDefunct != null)
2190    {
2191      addMonitorAttribute(attrs,
2192           ATTR_PREFIX_BIND_POOL + ATTR_SUFFIX_CLOSED_DEFUNCT,
2193           INFO_LDAP_EXT_SERVER_DISPNAME_BIND_CLOSED_DEFUNCT.get(),
2194           INFO_LDAP_EXT_SERVER_DESC_BIND_CLOSED_DEFUNCT.get(),
2195           bindPoolNumClosedDefunct);
2196    }
2197
2198    if (bindPoolNumClosedExpired != null)
2199    {
2200      addMonitorAttribute(attrs,
2201           ATTR_PREFIX_BIND_POOL + ATTR_SUFFIX_CLOSED_EXPIRED,
2202           INFO_LDAP_EXT_SERVER_DISPNAME_BIND_CLOSED_EXPIRED.get(),
2203           INFO_LDAP_EXT_SERVER_DESC_BIND_CLOSED_EXPIRED.get(),
2204           bindPoolNumClosedExpired);
2205    }
2206
2207    if (bindPoolNumClosedUnneeded != null)
2208    {
2209      addMonitorAttribute(attrs,
2210           ATTR_PREFIX_BIND_POOL + ATTR_SUFFIX_CLOSED_UNNEEDED,
2211           INFO_LDAP_EXT_SERVER_DISPNAME_BIND_CLOSED_UNNEEDED.get(),
2212           INFO_LDAP_EXT_SERVER_DESC_BIND_CLOSED_UNNEEDED.get(),
2213           bindPoolNumClosedUnneeded);
2214    }
2215
2216    if (bindPoolNumSuccessfulCheckouts != null)
2217    {
2218      addMonitorAttribute(attrs,
2219           ATTR_PREFIX_BIND_POOL + ATTR_SUFFIX_SUCCESSFUL_CHECKOUTS,
2220           INFO_LDAP_EXT_SERVER_DISPNAME_BIND_CHECKOUT_SUCCESS.get(),
2221           INFO_LDAP_EXT_SERVER_DESC_BIND_CHECKOUT_SUCCESS.get(),
2222           bindPoolNumSuccessfulCheckouts);
2223    }
2224
2225    if (bindPoolNumSuccessfulCheckoutsWithoutWaiting != null)
2226    {
2227      addMonitorAttribute(attrs,
2228           ATTR_PREFIX_BIND_POOL +
2229                ATTR_SUFFIX_SUCCESSFUL_CHECKOUTS_WITHOUT_WAITING,
2230           INFO_LDAP_EXT_SERVER_DISPNAME_BIND_CHECKOUT_NO_WAIT.get(),
2231           INFO_LDAP_EXT_SERVER_DESC_BIND_CHECKOUT_NO_WAIT.get(),
2232           bindPoolNumSuccessfulCheckoutsWithoutWaiting);
2233    }
2234
2235    if (bindPoolNumSuccessfulCheckoutsAfterWaiting != null)
2236    {
2237      addMonitorAttribute(attrs,
2238           ATTR_PREFIX_BIND_POOL +
2239                ATTR_SUFFIX_SUCCESSFUL_CHECKOUTS_AFTER_WAITING,
2240           INFO_LDAP_EXT_SERVER_DISPNAME_BIND_CHECKOUT_WITH_WAIT.get(),
2241           INFO_LDAP_EXT_SERVER_DESC_BIND_CHECKOUT_WITH_WAIT.get(),
2242           bindPoolNumSuccessfulCheckoutsAfterWaiting);
2243    }
2244
2245    if (bindPoolNumSuccessfulCheckoutsNewConnection != null)
2246    {
2247      addMonitorAttribute(attrs,
2248           ATTR_PREFIX_BIND_POOL +
2249                ATTR_SUFFIX_SUCCESSFUL_CHECKOUTS_NEW_CONN,
2250           INFO_LDAP_EXT_SERVER_DISPNAME_BIND_CHECKOUT_NEW_CONN.get(),
2251           INFO_LDAP_EXT_SERVER_DESC_BIND_CHECKOUT_NEW_CONN.get(),
2252           bindPoolNumSuccessfulCheckoutsNewConnection);
2253    }
2254
2255    if (bindPoolNumFailedCheckouts != null)
2256    {
2257      addMonitorAttribute(attrs,
2258           ATTR_PREFIX_BIND_POOL + ATTR_SUFFIX_FAILED_CHECKOUTS,
2259           INFO_LDAP_EXT_SERVER_DISPNAME_BIND_CHECKOUT_FAILED.get(),
2260           INFO_LDAP_EXT_SERVER_DESC_BIND_CHECKOUT_FAILED.get(),
2261           bindPoolNumFailedCheckouts);
2262    }
2263
2264    if (bindPoolNumReleasedValid != null)
2265    {
2266      addMonitorAttribute(attrs,
2267           ATTR_PREFIX_BIND_POOL + ATTR_SUFFIX_RELEASED_VALID,
2268           INFO_LDAP_EXT_SERVER_DISPNAME_BIND_RELEASED_VALID.get(),
2269           INFO_LDAP_EXT_SERVER_DESC_BIND_RELEASED_VALID.get(),
2270           bindPoolNumReleasedValid);
2271    }
2272
2273    if (nonBindPoolAvailableConnections != null)
2274    {
2275      addMonitorAttribute(attrs,
2276           ATTR_PREFIX_NONBIND_POOL + ATTR_SUFFIX_AVAILABLE_CONNS,
2277           INFO_LDAP_EXT_SERVER_DISPNAME_NONBIND_AVAILABLE_CONNS.get(),
2278           INFO_LDAP_EXT_SERVER_DESC_NONBIND_AVAILABLE_CONNS.get(),
2279           nonBindPoolAvailableConnections);
2280    }
2281
2282    if (nonBindPoolMaxAvailableConnections != null)
2283    {
2284      addMonitorAttribute(attrs,
2285           ATTR_PREFIX_NONBIND_POOL + ATTR_SUFFIX_MAX_AVAILABLE_CONNS,
2286           INFO_LDAP_EXT_SERVER_DISPNAME_NONBIND_MAX_AVAILABLE_CONNS.get(),
2287           INFO_LDAP_EXT_SERVER_DESC_NONBIND_MAX_AVAILABLE_CONNS.get(),
2288           nonBindPoolMaxAvailableConnections);
2289    }
2290
2291    if (nonBindPoolNumSuccessfulConnectionAttempts != null)
2292    {
2293      addMonitorAttribute(attrs,
2294           ATTR_PREFIX_NONBIND_POOL + ATTR_SUFFIX_SUCCESSFUL_CONNECTS,
2295           INFO_LDAP_EXT_SERVER_DISPNAME_NONBIND_CONNECT_SUCCESS.get(),
2296           INFO_LDAP_EXT_SERVER_DESC_NONBIND_CONNECT_SUCCESS.get(),
2297           nonBindPoolNumSuccessfulConnectionAttempts);
2298    }
2299
2300    if (nonBindPoolNumFailedConnectionAttempts != null)
2301    {
2302      addMonitorAttribute(attrs,
2303           ATTR_PREFIX_NONBIND_POOL + ATTR_SUFFIX_FAILED_CONNECTS,
2304           INFO_LDAP_EXT_SERVER_DISPNAME_NONBIND_CONNECT_FAILED.get(),
2305           INFO_LDAP_EXT_SERVER_DESC_NONBIND_CONNECT_FAILED.get(),
2306           nonBindPoolNumFailedConnectionAttempts);
2307    }
2308
2309    if (nonBindPoolNumClosedDefunct != null)
2310    {
2311      addMonitorAttribute(attrs,
2312           ATTR_PREFIX_NONBIND_POOL + ATTR_SUFFIX_CLOSED_DEFUNCT,
2313           INFO_LDAP_EXT_SERVER_DISPNAME_NONBIND_CLOSED_DEFUNCT.get(),
2314           INFO_LDAP_EXT_SERVER_DESC_NONBIND_CLOSED_DEFUNCT.get(),
2315           nonBindPoolNumClosedDefunct);
2316    }
2317
2318    if (nonBindPoolNumClosedExpired != null)
2319    {
2320      addMonitorAttribute(attrs,
2321           ATTR_PREFIX_NONBIND_POOL + ATTR_SUFFIX_CLOSED_EXPIRED,
2322           INFO_LDAP_EXT_SERVER_DISPNAME_NONBIND_CLOSED_EXPIRED.get(),
2323           INFO_LDAP_EXT_SERVER_DESC_NONBIND_CLOSED_EXPIRED.get(),
2324           nonBindPoolNumClosedExpired);
2325    }
2326
2327    if (nonBindPoolNumClosedUnneeded != null)
2328    {
2329      addMonitorAttribute(attrs,
2330           ATTR_PREFIX_NONBIND_POOL + ATTR_SUFFIX_CLOSED_UNNEEDED,
2331           INFO_LDAP_EXT_SERVER_DISPNAME_NONBIND_CLOSED_UNNEEDED.get(),
2332           INFO_LDAP_EXT_SERVER_DESC_NONBIND_CLOSED_UNNEEDED.get(),
2333           nonBindPoolNumClosedUnneeded);
2334    }
2335
2336    if (nonBindPoolNumSuccessfulCheckouts != null)
2337    {
2338      addMonitorAttribute(attrs,
2339           ATTR_PREFIX_NONBIND_POOL + ATTR_SUFFIX_SUCCESSFUL_CHECKOUTS,
2340           INFO_LDAP_EXT_SERVER_DISPNAME_NONBIND_CHECKOUT_SUCCESS.get(),
2341           INFO_LDAP_EXT_SERVER_DESC_NONBIND_CHECKOUT_SUCCESS.get(),
2342           nonBindPoolNumSuccessfulCheckouts);
2343    }
2344
2345    if (nonBindPoolNumSuccessfulCheckoutsWithoutWaiting != null)
2346    {
2347      addMonitorAttribute(attrs,
2348           ATTR_PREFIX_NONBIND_POOL +
2349                ATTR_SUFFIX_SUCCESSFUL_CHECKOUTS_WITHOUT_WAITING,
2350           INFO_LDAP_EXT_SERVER_DISPNAME_NONBIND_CHECKOUT_NO_WAIT.get(),
2351           INFO_LDAP_EXT_SERVER_DESC_NONBIND_CHECKOUT_NO_WAIT.get(),
2352           nonBindPoolNumSuccessfulCheckoutsWithoutWaiting);
2353    }
2354
2355    if (nonBindPoolNumSuccessfulCheckoutsAfterWaiting != null)
2356    {
2357      addMonitorAttribute(attrs,
2358           ATTR_PREFIX_NONBIND_POOL +
2359                ATTR_SUFFIX_SUCCESSFUL_CHECKOUTS_AFTER_WAITING,
2360           INFO_LDAP_EXT_SERVER_DISPNAME_NONBIND_CHECKOUT_WITH_WAIT.get(),
2361           INFO_LDAP_EXT_SERVER_DESC_NONBIND_CHECKOUT_WITH_WAIT.get(),
2362           nonBindPoolNumSuccessfulCheckoutsAfterWaiting);
2363    }
2364
2365    if (nonBindPoolNumSuccessfulCheckoutsNewConnection != null)
2366    {
2367      addMonitorAttribute(attrs,
2368           ATTR_PREFIX_NONBIND_POOL +
2369                ATTR_SUFFIX_SUCCESSFUL_CHECKOUTS_NEW_CONN,
2370           INFO_LDAP_EXT_SERVER_DISPNAME_NONBIND_CHECKOUT_NEW_CONN.get(),
2371           INFO_LDAP_EXT_SERVER_DESC_NONBIND_CHECKOUT_NEW_CONN.get(),
2372           nonBindPoolNumSuccessfulCheckoutsNewConnection);
2373    }
2374
2375    if (nonBindPoolNumFailedCheckouts != null)
2376    {
2377      addMonitorAttribute(attrs,
2378           ATTR_PREFIX_NONBIND_POOL + ATTR_SUFFIX_FAILED_CHECKOUTS,
2379           INFO_LDAP_EXT_SERVER_DISPNAME_NONBIND_CHECKOUT_FAILED.get(),
2380           INFO_LDAP_EXT_SERVER_DESC_NONBIND_CHECKOUT_FAILED.get(),
2381           nonBindPoolNumFailedCheckouts);
2382    }
2383
2384    if (nonBindPoolNumReleasedValid != null)
2385    {
2386      addMonitorAttribute(attrs,
2387           ATTR_PREFIX_NONBIND_POOL + ATTR_SUFFIX_RELEASED_VALID,
2388           INFO_LDAP_EXT_SERVER_DISPNAME_NONBIND_RELEASED_VALID.get(),
2389           INFO_LDAP_EXT_SERVER_DESC_NONBIND_RELEASED_VALID.get(),
2390           nonBindPoolNumReleasedValid);
2391    }
2392
2393    if (addAttempts != null)
2394    {
2395      addMonitorAttribute(attrs,
2396           ATTR_ADD_ATTEMPTS,
2397           INFO_LDAP_EXT_SERVER_DISPNAME_ADD_ATTEMPTS.get(),
2398           INFO_LDAP_EXT_SERVER_DESC_ADD_ATTEMPTS.get(),
2399           addAttempts);
2400    }
2401
2402    if (addFailures != null)
2403    {
2404      addMonitorAttribute(attrs,
2405           ATTR_ADD_FAILURES,
2406           INFO_LDAP_EXT_SERVER_DISPNAME_ADD_FAILURES.get(),
2407           INFO_LDAP_EXT_SERVER_DESC_ADD_FAILURES.get(),
2408           addFailures);
2409    }
2410
2411    if (addSuccesses != null)
2412    {
2413      addMonitorAttribute(attrs,
2414           ATTR_ADD_SUCCESSES,
2415           INFO_LDAP_EXT_SERVER_DISPNAME_ADD_SUCCESSES.get(),
2416           INFO_LDAP_EXT_SERVER_DESC_ADD_SUCCESSES.get(),
2417           addSuccesses);
2418    }
2419
2420    if (bindAttempts != null)
2421    {
2422      addMonitorAttribute(attrs,
2423           ATTR_BIND_ATTEMPTS,
2424           INFO_LDAP_EXT_SERVER_DISPNAME_BIND_ATTEMPTS.get(),
2425           INFO_LDAP_EXT_SERVER_DESC_BIND_ATTEMPTS.get(),
2426           bindAttempts);
2427    }
2428
2429    if (bindFailures != null)
2430    {
2431      addMonitorAttribute(attrs,
2432           ATTR_BIND_FAILURES,
2433           INFO_LDAP_EXT_SERVER_DISPNAME_BIND_FAILURES.get(),
2434           INFO_LDAP_EXT_SERVER_DESC_BIND_FAILURES.get(),
2435           bindFailures);
2436    }
2437
2438    if (bindSuccesses != null)
2439    {
2440      addMonitorAttribute(attrs,
2441           ATTR_BIND_SUCCESSES,
2442           INFO_LDAP_EXT_SERVER_DISPNAME_BIND_SUCCESSES.get(),
2443           INFO_LDAP_EXT_SERVER_DESC_BIND_SUCCESSES.get(),
2444           bindSuccesses);
2445    }
2446
2447    if (compareAttempts != null)
2448    {
2449      addMonitorAttribute(attrs,
2450           ATTR_COMPARE_ATTEMPTS,
2451           INFO_LDAP_EXT_SERVER_DISPNAME_COMPARE_ATTEMPTS.get(),
2452           INFO_LDAP_EXT_SERVER_DESC_COMPARE_ATTEMPTS.get(),
2453           compareAttempts);
2454    }
2455
2456    if (compareFailures != null)
2457    {
2458      addMonitorAttribute(attrs,
2459           ATTR_COMPARE_FAILURES,
2460           INFO_LDAP_EXT_SERVER_DISPNAME_COMPARE_FAILURES.get(),
2461           INFO_LDAP_EXT_SERVER_DESC_COMPARE_FAILURES.get(),
2462           compareFailures);
2463    }
2464
2465    if (compareSuccesses != null)
2466    {
2467      addMonitorAttribute(attrs,
2468           ATTR_COMPARE_SUCCESSES,
2469           INFO_LDAP_EXT_SERVER_DISPNAME_COMPARE_SUCCESSES.get(),
2470           INFO_LDAP_EXT_SERVER_DESC_COMPARE_SUCCESSES.get(),
2471           compareSuccesses);
2472    }
2473
2474    if (deleteAttempts != null)
2475    {
2476      addMonitorAttribute(attrs,
2477           ATTR_DELETE_ATTEMPTS,
2478           INFO_LDAP_EXT_SERVER_DISPNAME_DELETE_ATTEMPTS.get(),
2479           INFO_LDAP_EXT_SERVER_DESC_DELETE_ATTEMPTS.get(),
2480           deleteAttempts);
2481    }
2482
2483    if (deleteFailures != null)
2484    {
2485      addMonitorAttribute(attrs,
2486           ATTR_DELETE_FAILURES,
2487           INFO_LDAP_EXT_SERVER_DISPNAME_DELETE_FAILURES.get(),
2488           INFO_LDAP_EXT_SERVER_DESC_DELETE_FAILURES.get(),
2489           deleteFailures);
2490    }
2491
2492    if (deleteSuccesses != null)
2493    {
2494      addMonitorAttribute(attrs,
2495           ATTR_DELETE_SUCCESSES,
2496           INFO_LDAP_EXT_SERVER_DISPNAME_DELETE_SUCCESSES.get(),
2497           INFO_LDAP_EXT_SERVER_DESC_DELETE_SUCCESSES.get(),
2498           deleteSuccesses);
2499    }
2500
2501    if (modifyAttempts != null)
2502    {
2503      addMonitorAttribute(attrs,
2504           ATTR_MODIFY_ATTEMPTS,
2505           INFO_LDAP_EXT_SERVER_DISPNAME_MODIFY_ATTEMPTS.get(),
2506           INFO_LDAP_EXT_SERVER_DESC_MODIFY_ATTEMPTS.get(),
2507           modifyAttempts);
2508    }
2509
2510    if (modifyFailures != null)
2511    {
2512      addMonitorAttribute(attrs,
2513           ATTR_MODIFY_FAILURES,
2514           INFO_LDAP_EXT_SERVER_DISPNAME_MODIFY_FAILURES.get(),
2515           INFO_LDAP_EXT_SERVER_DESC_MODIFY_FAILURES.get(),
2516           modifyFailures);
2517    }
2518
2519    if (modifySuccesses != null)
2520    {
2521      addMonitorAttribute(attrs,
2522           ATTR_MODIFY_SUCCESSES,
2523           INFO_LDAP_EXT_SERVER_DISPNAME_MODIFY_SUCCESSES.get(),
2524           INFO_LDAP_EXT_SERVER_DESC_MODIFY_SUCCESSES.get(),
2525           modifySuccesses);
2526    }
2527
2528    if (modifyDNAttempts != null)
2529    {
2530      addMonitorAttribute(attrs,
2531           ATTR_MODIFY_DN_ATTEMPTS,
2532           INFO_LDAP_EXT_SERVER_DISPNAME_MODIFY_DN_ATTEMPTS.get(),
2533           INFO_LDAP_EXT_SERVER_DESC_MODIFY_DN_ATTEMPTS.get(),
2534           modifyDNAttempts);
2535    }
2536
2537    if (modifyDNFailures != null)
2538    {
2539      addMonitorAttribute(attrs,
2540           ATTR_MODIFY_DN_FAILURES,
2541           INFO_LDAP_EXT_SERVER_DISPNAME_MODIFY_DN_FAILURES.get(),
2542           INFO_LDAP_EXT_SERVER_DESC_MODIFY_DN_FAILURES.get(),
2543           modifyDNFailures);
2544    }
2545
2546    if (modifyDNSuccesses != null)
2547    {
2548      addMonitorAttribute(attrs,
2549           ATTR_MODIFY_DN_SUCCESSES,
2550           INFO_LDAP_EXT_SERVER_DISPNAME_MODIFY_DN_SUCCESSES.get(),
2551           INFO_LDAP_EXT_SERVER_DESC_MODIFY_DN_SUCCESSES.get(),
2552           modifyDNSuccesses);
2553    }
2554
2555    if (searchAttempts != null)
2556    {
2557      addMonitorAttribute(attrs,
2558           ATTR_SEARCH_ATTEMPTS,
2559           INFO_LDAP_EXT_SERVER_DISPNAME_SEARCH_ATTEMPTS.get(),
2560           INFO_LDAP_EXT_SERVER_DESC_SEARCH_ATTEMPTS.get(),
2561           searchAttempts);
2562    }
2563
2564    if (searchFailures != null)
2565    {
2566      addMonitorAttribute(attrs,
2567           ATTR_SEARCH_FAILURES,
2568           INFO_LDAP_EXT_SERVER_DISPNAME_SEARCH_FAILURES.get(),
2569           INFO_LDAP_EXT_SERVER_DESC_SEARCH_FAILURES.get(),
2570           searchFailures);
2571    }
2572
2573    if (searchSuccesses != null)
2574    {
2575      addMonitorAttribute(attrs,
2576           ATTR_SEARCH_SUCCESSES,
2577           INFO_LDAP_EXT_SERVER_DISPNAME_SEARCH_SUCCESSES.get(),
2578           INFO_LDAP_EXT_SERVER_DESC_SEARCH_SUCCESSES.get(),
2579           searchSuccesses);
2580    }
2581
2582    return Collections.unmodifiableMap(attrs);
2583  }
2584}