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