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