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