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