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