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