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